lua5.2參考手冊—keyring (譯) keyrings@163.com
Lua 5.2 參考手冊
by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celeshtml
Copyright © 2011–2013 Lua.org, PUC-Rio. Freely available under the terms of the Lua license.git
keyring (譯) keyrings@163.com程序員
開始 · 目錄 · 索引 · 英文版 · Githubgithub
目錄
- 1 – 簡介
- 2 – 基本概念
- 3 – 語言
- 4 – 應用程序接口
- 4.1 – 棧
- 4.2 – 棧的大小
- 4.3 – 有效索引與合法索引
- 4.4 – C 閉包
- 4.5 – 註冊表
- 4.6 – C 中的錯誤處理
- 4.7 – C 中的掛起處理
- 4.8 – 函數與類型
- 4.9 – 調試接口
- 5 – The Auxiliary Library
- 6 – Standard Libraries
- 6.1 – Basic Functions
- 6.2 – Coroutine Manipulation
- 6.3 – Modules
- 6.4 – String Manipulation
- 6.5 – Table Manipulation
- 6.6 – Mathematical Functions
- 6.7 – Bitwise Operations
- 6.8 – Input and Output Facilities
- 6.9 – Operating System Facilities
- 6.10 – The Debug Library
- 7 – Lua Standalone
- 8 – Incompatibilities with the Previous Version
- 9 – The Complete Syntax of Lua
索引
1 – 簡介
Lua 是一門擴展型程序設計語言，用於輔助通常的過程式編程。固然，它也對面向對象編程、函數式編程和數據驅動式編程提供良好的支持。Lua 做爲一門強大、輕量、可嵌入式的腳本語言能供任何須要的程序使用。Lua 是由 clean C（標準 C和C++的一個共通子集）實現的一個庫。
做爲一門擴展型語言，Lua沒有「main」程序的概念：它只能嵌入宿主程序，宿主程序被稱爲 embedding program 或者簡稱 host。宿主程序能夠調用函數執行一段 Lua 代碼，能夠讀寫 Lua 變量，甚至能夠註冊 C 函數以在Lua代碼中調用。經過對 C 函數的使用，Lua足以應付各類領域，徹底能夠共享一個句法框架而定製不一樣的程序語言。Lua官方發佈版包含一個叫 lua 的宿主程序示例，它是一個利用Lua庫寫成的完整獨立的Lua解釋器，通常用於交互和批處理。
Lua 做爲自由軟件,就像license裏面所說，使用它是不須要抵押品的 :)。本手冊所描述的實現能夠在 Lua 官方網站 www.lua.org 中找到。
就像任何參考手冊同樣，這份文檔某些地方有點枯燥。關於 Lua 背後設計思想的探討，能夠看看 Lua 官方網站上的技術論文。至於Lua編程的詳細介紹，請參閱Roberto的書， Programming in Lua（當前最新是第三版）。
2 – 基本概念
本章節介紹 Lua 語言裏的基本概念。
2.1 – 值與類型
Lua 是一門動態類型語言。這意味着變量沒有類型，只有值。Lua 沒有類型定義，由值自己攜帶本身的類型信息。
Lua 中的全部值均是 first-class values（第一類值）。這意味着全部的值都可存於變量中，也可做爲參數傳遞給其餘函數，也可做爲函數結果被返回。
Lua中有八種基本類型： nil（空）、boolean（布爾）、number（數字）、string（字符串）、function（函數）、userdata（用戶數據）、thread（線程）和 table（表）。
Nil 類型只有值 nil，主要用於標識與其餘值的不一樣；一般表明無心義的值。
Boolean 類型只有兩種值 false 和 true。 nil 和 false 都表示條件爲假；而其餘任何值均表示爲真。
Number 表示實數（雙精度浮點數）。數字間的運算操做與底層C實現遵循相同的規則，通常就是IEEE754標準。（使用內部其餘數字類型如單精度浮點或長整型從新編譯一個Lua解釋器也很是容易；參見 luaconf.h 文件。）
String 表明字節串。Lua is 8-bit clean：字符串能夠包含任意8-bit值，包括 '\0' 。
Lua 能夠調用（操做）由 Lua 和 C 寫成的 Function （參見 §3.4.9）。
userdata 類型用來將任意 C 數據保存在 Lua 變量中。 一個 userdata 類型的值就是一塊原生內存的指針。 userdata 分兩類：full userdata 和 light userdata ，前者的內存塊由 Lua 管理；後者的內存塊由 host 管理。 Userdata 在 Lua 中除了賦值與鑑定測試便沒有其餘預約義操做了。可是經過使用 metatables（元表），程序員能夠爲 full userdata 類型的值自定義操做（參見 §2.4）。 Userdata 類型的值不能在 Lua 中建立與修改，只能經過 C API。這樣保證了宿主程序能徹底掌管其中的數據。
thread 表明獨立的執行線程，用於實現 coroutines（協同程序）（參見 §2.6）。不要把 Lua 線程與操做系統線程搞混。Lua 在全部系統上均支持 coroutines，即便系統並不支持 threads 。
table 類型實現了關聯數組。也就是說，該數組能夠用任何 Lua 值（除了nil 和 NaN）做索引，而不只限於數字。 Tables 能夠包含全部類型的值（除了nil）。任何帶 nil 值的鍵都不是 table 的一部分。相應的，任何不屬於 table 的鍵都關聯一個 nil 值。
Table 是 Lua 中惟一的數據組織機制，能夠用於表示普通數組、序列、符號表、集合、記錄、圖、樹等等。在表示記錄時，Lua 以域做爲索引。語言支持以 a.name 來表示 a["name"]，這只是一種語法糖。table 的建立方式有不少種（參見 §3.4.8）。
咱們使用 序列 這個詞來表示一個遞增表，其索引爲 {1..n} ，其中的 n 表示序列的長度（參見 §3.4.6）。
與索引同樣，table 中的域也可爲任意類型。特別的，因爲函數也是 first-class values （第一類值/一等公民），因此 table 的域也可包含函數。從而 table 也能攜帶 methods （參見 §3.4.10）。（譯註：這爲面向對象提供了基礎）
table 的索引遵循語言中定義的原生相等性。表達式 a[i] 與 a[j] 只在 i 與 j 原生相等（指無元方法的相等）時才表示同一個表元素。
Table、function、thread 和 (full) userdata 類型的值均是 對象：變量實際上不含有 值，只是引用 值。賦值、參數傳遞和函數返回等操控的只是值的引用；這些操做不會作任何性質的拷貝。
庫函數 type 能夠返回一個給定值的類型（參見 §6.1）。
2.2 – 環境與全局變量
就像在 §3.2 和 §3.3.3 討論的那樣，任何對全局名稱 var 的引用均會被翻譯成 _ENV.var。此外，任何在局部變量以外編譯的程序塊均叫做 _ENV（參見 §3.3.2）， 因此 _ENV 自己在程序塊中歷來都不是全局名稱。
儘管存在外部 _ENV 變量用於全局名稱的翻譯，_ENV 自己實際上是一個徹底符合命名規則的名稱。你徹底能夠定義新的變量/參數並取這個名字。每一次使用 _ENV 對全局名稱的引用在當時對程序是可見的，徹底遵循 Lua 通用可見性規則（參見 §3.5）。
任何被存儲 _ENV 值的表叫做 environment（環境）.
Lua 維持一個叫 global environment（全局環境）的特殊環境。這個值在 C 註冊表（參見 §4.5）表示一個特殊索引。在 Lua 中，變量 _G 被初始化爲相同值。
當 Lua 編譯一個 chunk（程序塊）時，會先將其中 _ENV 的值提高爲全局環境（參見 load）。所以，默認狀況下，Lua代碼中的全局變量通常指的是全局環境裏的入口。此外，加載到全局環境下的全部標準庫和部分函數均是在該環境下運做。你可使用 load （或者 loadfile）來加載一個不一樣環境下的 chunk。
若是你改變了註冊表中的全局環境（經過 C 代碼或者 debug 庫），在改變以後加載的 chunk 將得到新的環境。先前加載的 chunk 雖不受影響，但都要在自身的 _ENV 變量中引用到新環境去。此外，Lua 從不更新變量 _G（存於原始全局環境）。
2.3 – 錯誤處理
因爲 Lua 是一門嵌入式擴展語言，全部的 Lua 行爲均源於宿主程序 C 代碼對 Lua 庫的函數調用（參見 lua_pcall）。不管什麼時候 Lua 程序塊發生編譯/執行錯誤，控制權均會交給宿主程序，由宿主程序觸發恰當的措施（好比打印一條出錯信息）。
Lua 代碼能夠經過調用 error 函數明確產生錯誤信息。若是須要在 Lua 中 捕捉錯誤，可使用 pcall 或 xpcall 來在 protected mode（保護模式）下調用一個處理函數。
每產生一個錯誤，就會傳播一個包含該錯誤信息的 error object（錯誤對象） （也叫 error message（錯誤消息））。Lua 自己只爲錯誤對象產生一條字符串錯誤信息，而程序能夠爲錯誤對象產生任何形式的錯誤信息。
當使用 xpcall 或者 lua_pcall時，能夠傳遞一個 message handler（消息處理程序）以在錯誤出現時調用。這個程序由原始錯誤消息調用並返回一條新的消息。它在錯誤離開棧以前被調用，故能收集更多關於錯誤的信息，好比檢查堆棧和建立堆棧回溯。這個消息處理程序在保護模式下被調用，自身也處在保護中，所以，消息處理中出現錯誤的話將再次調用消息處理（也就是本身）。若是發生了這種循環，將由 Lua 中斷並返回一段恰當的消息。
2.4 – 元表與元方法
Lua 中的每一個值均能擁有一個metatable（元表）。這個 metatable 就是普通的 Lua table，而後定義了一些原始值在特定操做下的行爲。你能夠經過在一個值的元表中設置特定的域來改變操做行爲。例如，當一個非數字的值要作加法操做，Lua 會查詢該值的元表中 "__add" 域中的函數，若是找到一個函數，Lua 則調用該函數來執行加法。
元表中的鍵命名爲 event（事件）；對應的值叫 metamethods（元方法）。在剛纔的例子中，事件是 "add"，元方法則是那個執行加法操做的函數。
你可使用 getmetatable 函數來查詢任何值的 metatable（元表）。
你可使用 setmetatable 函數來替換 table 的 metatable 。但不能在 Lua 中改變其餘類型（好比 number、string類型）的 metatable（除非使用 debug 庫），必須得使用 C API。
每一個 table 和 full userdata 擁有獨立的 metatable（雖然多個 table 和 userdata 也可共享它們的 metatable）。而全部其餘類型的值，一種類型只有一個 metatable；意味着全部數字只有一個 metatable，全部字符串也同樣，等等。默認狀況下，單個值是沒有 metatable 的，但字符串庫爲 string 類型設置了一個 metatable（參見 §6.4）。
一個 metatable 控制着一個對象在數學運算、比較、鏈接、取長和索引等操做的行爲表現。它也能定義函數，讓 userdata 或者 table 作垃圾收集時調用。當 Lua 須要對某個值執行其中一種操做時，會先檢查值的 metatable 中是否有對應的事件。若是有，鍵對應的值（metamethod 元方法）將決定 Lua 如何執行操做。
Metatable 能控制的操做全列在了下面。各類操做用對應的名字區分。每種操做的鍵都是操做名前面加上兩個下劃線 （ '__' ）的字符串。好比 "add" 操做的鍵就是字符串 "__add"。
這些操做的含義由 Lua 函數來解釋更準確，畢竟函數展現瞭解釋器內部如何執行該操做。這裏的 Lua 代碼僅用做解釋說明，實際的行爲已經硬編碼在解釋器中，天然也比這些模擬代碼高效。在下面代碼使用到的 rawget, tonumber 等等函數可在 §6.1 找到。注意，咱們使用下面一行表達式來從給定對象中提取元方法
metatable(obj)[event]
可被解讀成
rawget(getmetatable(obj) or {}, event)
這意味着訪問一個元方法不會調用其餘元方法，並且訪問沒有 metatable 的對象也不會失敗（僅僅致使 nil）。
對於一元操做符 - 和 #，元方法由虛擬的第二參數調用。這個額外的參數僅用於簡化 Lua 的內建對象；在未來的版本中可能被移除，所以咱們不會在下面討論。（其實額外參數的大部分使用都是可有可無的。）
- "add":
+操做。下面的
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 -- 兩個操做數均爲數字？ return o1 + o2 -- 這裏的 '+' 就是基本加法（ 'add'） else -- 至少有一個操做數不是數字 local h = getbinhandler(op1, op2, "__add") if h then -- 以兩個操做數調用處理方法 return (h(op1, op2)) else -- 沒有處理方法：默認行爲 error(···) end end end - "sub"：
-操做， 行爲相似 "add" 操做。 - "mul"：
*操做， 行爲相似 "add" 操做。 - "div"：
/操做， 行爲相似 "add" 操做。 - "mod"：
%操做， 行爲相似 "add" 操做，原始操做是o1 - floor(o1/o2)*o2。 - "pow"：
^（冪）操做。 行爲相似 "add" 操做，原始操做是pow函數（來自 C math 庫）。 - "unm"： 一元
-操做。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 - "len"：
#操做。function len_event (op) if type(op) == "string" then return strlen(op) -- primitive string length else local h = metatable(op).__len if h then return (h(op)) -- call handler with the operand elseif type(op) == "table" then return #op -- primitive table length else -- no handler available: error error(···) end end end關於 table 的長度請參閱 §3.4.6。
- "eq"：
==操做。 函數getequalhandler定義了 Lua 如何選擇元方法進行相等操做。只有當兩個被比較的值類型相同，並且在當前操做下擁有相同的元方法，並且不屬於 table 或 full userdata 間的一種時，被選出的元方法纔會有效。function getequalhandler (op1, op2) if type(op1) ~= type(op2) or (type(op1) ~= "table" and type(op1) ~= "userdata") then return nil -- different values end local mm1 = metatable(op1).__eq local mm2 = metatable(op2).__eq if mm1 == mm2 then return mm1 else return nil end end"eq" 事件定義以下：
function eq_event (op1, op2) if op1 == op2 then -- primitive equal? return true -- values are equal end -- try metamethod local h = getequalhandler(op1, op2) if h then return not not h(op1, op2) else return false end end注意結果常爲 boolean 值。
- "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 = getbinhandler(op1, op2, "__lt") if h then return not not h(op1, op2) else error(···) end end end注意結果常爲 boolean 值。
- "le":
<=操做。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 = getbinhandler(op1, op2, "__le") if h then return not not h(op1, op2) else h = getbinhandler(op1, op2, "__lt") if h then return not h(op2, op1) else error(···) end end end end注意，缺乏 "le" 元方法時，Lua 就嘗試 "lt"，並假定
a <= b等價於not (b < a)。就像其餘比較運算符，其結果常爲 boolean 值。
- "index"： 索引操做用於訪問
table[key]。注意僅當key不在table中時，纔會嘗試元方法。（當table不是表時，裏面沒有鍵，因此會一直嘗試元方法。）function gettable_event (table, key) local h if type(table) == "table" then local v = rawget(table, key) -- if key is present, return raw value 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"： 賦值給索引
table[key] = value。注意僅當key不在table中時，纔會嘗試元方法。function settable_event (table, key, value) local h if type(table) == "table" then local v = rawget(table, key) -- if key is present, do raw assignment 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 - "call"： 當 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
2.5 – 垃圾收集
Lua 實行自動內存管理。意味着你不用擔憂建立新對象時的內存分配，也不用擔憂對象再也不須要時的內存釋放。Lua 運行一個 garbage collector（垃圾收集器） 來自動管理內存，收集 dead objects（死亡對象）（指 Lua 再也不訪問的對象）。Lua 中使用的全部內存（對象）均被自動管理：strings、tables、userdata、functions、threads、internal structures 等等。
Lua 實現了一個增量標記-清除收集器。它使用兩個數字來控制垃圾收集週期： garbage-collector pause 和 garbage-collector step multiplier。二者均使用百分點做爲計數單元（好比，100在內在表示 爲1個百分點）。
garbage-collector pause 控制着收集器在開始新週期前的停頓時長。數字越大收集器越不積極，停頓時間越長。小於100意味着收集器不停頓即開始新週期。200表示收集器在內存使用量達到原來的兩倍時纔會開啓新的週期。
garbage-collector step multiplier 控制收集器與內存分配的相對速度。數字越大收集器越積極，增長的收集量也越大。小於100會讓收集器工做的很是慢，甚至形成收集器永遠沒法結束當前週期。默認值爲200，表示收集器之內存分配的兩倍速度運行着。
若是你將 step multiplier 設置的很是大（比程序中可能使用到的最大字節數還要大10%），收集器的行爲將相似 stop-the-world 收集器（即爲了完成一個完整的垃圾收集週期而暫停與主程序的交互）。若是你同時又將 pause 設成200，那收集器就像老版本的Lua同樣，等內存使用量達到 Lua 自己使用量的兩倍纔會作一次徹底的垃圾回收。
你能夠經過在 C 中調用 lua_gc 或者在 Lua 中調用 collectgarbage 來改變這些數字。你也能夠經過這些函數來直接控制垃圾收集器（好比關閉、重啓之類）。
做爲 Lua 5.2 中的一個實驗特性，你能夠改變收集器的操做模式，從 incremental 改爲generational。generational collector 假設大部分對象存活時間很短，所以收集器只會檢測最近建立的新對象。這種行爲能下降收集器的使用時間，但會增長內存使用量（逐漸累積老死的對象）。要解決第二個問題，可讓 generational collector 時常執行完整的回收。記住，這只是處於實驗階段的特性，歡迎嘗試，看看效果咋樣。
2.5.1 – 垃圾收集元方法
你能夠爲 table 設置垃圾收集元方法，也可以使用 C API 爲 full userdata 設置（參見 §2.4）。這些元方法也叫 finalizers（析構器）。析構器容許外部資源管理（好比關閉文件、關閉網絡、關閉數據庫鏈接或者釋放本身的內存）配合 Lua 的垃圾收集。
對象（table 或者 userdata）須要被析構回收時，你必須 標記 它爲可析構。只需爲對象設置一張有 "__gc 域的元表便可標記對象爲可析構。注意一點，若是你爲對象先設置了一張沒有 __gc 域的元表，而後在元表中新建一個 __gc 域，這個對象是無法被標記的。而在對象被標記後，你能夠隨意改變元表中的 __gc 域 。
當被標記對象變成垃圾時，垃圾收集器不會立馬將它回收，而是由 Lua 將之放進一個列表中。收集結束後，Lua 對列表中每一個對象執行下面函數的等價操做：
function gc_event (obj)
local h = metatable(obj).__gc
if type(h) == "function" then
h(obj)
end
end
每一個垃圾收集週期的結尾，當前週期內收集到的垃圾對象會以被標記順序的 反序 調用析構器。這意味着程序裏最後被標記的對象最早析構。析構器的執行可能發生在普通代碼執行期間的任什麼時候候。
因爲被回收了的對象還要被析構器使用，該對象會由 Lua resurrected（復活）。固然，這個復活是短暫的，並且對象的內存會在下一個垃圾收集週期釋放掉。然而，若是析構器將對象存在某些全局位置（好比一個全局變量裏面），那這就變成永久性復活了。總之，對象的內存只有在徹底不可訪問的狀況下才能被釋放；它的析構器也從不會被調用兩次。
當關閉一個狀態（參見 lua_close），Lua將對全部被標記爲可析構的對象以標記的反序來調用析構器。若是恰好有新對象在這個階段被標記，新對象是不會被析構的。
2.5.2 – 弱表
weak table 指表中元素被 weak references（弱引用）。而垃圾收集器會忽略弱引用，換言之，若是一個對象只有弱引用，垃圾收集器會將之回收。
弱表的鍵與值都可爲 weak。擁有弱鍵的表，鍵會被回收而對應的值不會。而鍵與值都 weak 的話，收集器會將鍵與值都回收掉。並且，不管鍵與值誰被回收了，對應的鍵值對都會從表中移除。table 的 weak 性質受元表的 __mode 域控制。若是 __mode 域是一個含有字符 'k' 的字符串，則 table 中的鍵就是 weak 的；相應的，若是 __mode 域含有字符 'v'，table 中的值就是 weak 的。
擁有弱鍵與強值的表也叫 ephemeron table（短命表）。在這種表中，值的可訪問性只依賴對應鍵的可訪問性。尤爲是鍵的惟一引用來自它的值時，這個鍵值對將被移除。
對錶的 weak 性質作任何改變只會對下一個垃圾收集週期產生影響。並且，若是你改爲更 strong（強）的模式，Lua 在更改真正生效以前仍然會回收表中某些項。
只有那些明確說明的對象纔會從弱表中移除。數字和輕量 C 函數之類不受垃圾收集管理，所以不會從弱表中移除（除非它的關聯值已被回收了）。雖然字符串受垃圾收集管理，但它們沒有明確說明，所以也不會從弱表中移除。
復活的對象（指那些即將析構且只能由析構器訪問的對象）在弱表中有一種特殊行爲。它們在運行自身析構器以前會從弱值中移除，但只能在下一個垃圾收集週期從弱鍵中移除，此時纔是真正的對象釋放。這種行爲就容許析構器在弱表中訪問與對象相關的屬性。
若是一個弱表在當前回收週期位於一個復活對象中，那隻能在下一個週期裏才能正確清除掉。
2.6 – 協程
Lua 支持 coroutines（協程），也叫 collaborative multithreading（協同多線程）。Lua 中的每一個協程都在各自獨立的線程中執行。不像多線程系統中的線程，協程只會在顯示調用 yield 函數時掛起。
調用 coroutine.create 會建立一個協程，其參數就是協程的主函數。 這個 create 函數僅僅建立新的協程並返回句柄（一個類型爲 thread 的對象），而不會啓動協程。
調用 coroutine.resume 就開始執行協程。當你首次調用 coroutine.resume，需傳入的第一個參數就是coroutine.create 返回的 thread。而後協程從它的主函數第一行開始執行。接下來傳入 coroutine.resume 的其餘參數均會傳遞給協程的主函數。協程一旦運行，直到終止或者掛起。
協程有兩種方式終止執行：正常退出和異常退出，前者指由它的主函數返回退出（不管最後有沒有顯示 return），這時coroutine.resume 返回 true，並附帶協程主函數的返回值；後者指發生未預防的錯誤，這時 coroutine.resume 返回 false，並附加一條錯誤消息。
調用 coroutine.yield 能使協程掛起。當協程發生掛起時，相應的 coroutine.resume 會馬上返回，即便掛起發生在內層函數調用中（這意味着不限於在主函數以內，其餘受主函數直接/間接調用的函數以內也能發生）。協程的掛起，使coroutine.resume 一樣返回 true，並附帶那些傳遞給 coroutine.yield 的參數值。再次調用 coroutine.yield 將恢復該協程，並從掛起的斷點處繼續執行，其返回值則是傳遞給 coroutine.resume 的參數值。
相似 coroutine.create，coroutine.wrap 函數也能建立協程，但返回的不是協程自己，而是一個能從新得到協程的函數。傳遞給 wrap 函數的任何參數都將做爲 coroutine.resume的額外參數。 coroutine.wrap 返回coroutine.resume 返回值中除第一個（boolean型錯誤代碼）以外其餘全部值。與 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
你也能夠經過 C API 來建立和操做協程：參閱 lua_newthread、lua_resume、lua_yield 等函數。
3 – 語言
本章介紹 Lua 的詞法、語法和句法。換言之，這一章介紹哪些 token（符號）是合法的，它們如何組合，以及組合後的含義。
語言的結構由經常使用的擴展BNF範式來表示，即 {a} 表示0或多個 a，[a] 表示 a 爲可選項。非終結符（通常是語言裏的語法成分）保持不變，關鍵字相似 kword，其他的終結符（語言字符集的基本字符）要像這樣 ‘=’ 位於引號中。完整的 Lua 語法可在本手冊最末處 §9 找到。
3.1 – 詞法規定
Lua 是門 free-form 語言。除了名字與關鍵字間的分隔符，它將忽略詞法元素（符號）之間的空白（包括換行）和註釋。
Lua 中的 Names（名字） （也叫 identifiers（標識符））能夠是任何字母、數字、下劃線組成的非數字開頭的字符串。標識符用於命名變量、表的域和標籤。
下面是 Lua 保留的 keywords（關鍵字），不能用做名字：
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
Lua 區分大小寫： and 是保留字，但 And 和 AND 則是兩個不一樣的合法名字。通常約定，如下劃線開頭接大寫字母的名字（好比 _VERSION）被保留用於 Lua 內部變量。
下面是其餘符號：
+ - * / % ^ #
== ~= <= >= < > =
( ) { } [ ] ::
; : , . .. ...
Literal strings（文字串） 能夠放在單雙引號內，其中也可包含相似 C 中的轉義序列： '\a' (響鈴)， '\b' (退格)， '\f' (換頁)， '\n' (換行)， '\r' (回車)， '\t' (橫向製表)， '\v' (縱向製表)， '\\' (反斜線)， '\"' (雙引號)， 和 '\'' (單引號)。 一個反斜線後跟一個換行符（\\n）會讓字符串中產生一個換行符號（\n）。轉義序列 '\z' 會跳事後面的空白字符，包括換行符；這個在將一段很長的文字串截成多行時很是有用。
文字串中的字節也可經過數字表示出來。使用轉義序列 \xXX便可辦到， XX 是兩個十六進制數字；或者使用轉義序列 \ddd，ddd 表示最多三個十進制數字的序列。（注意，若是要在轉義以後跟一個數字，那斜線後必須寫滿三個數字，不然會有歧義。）Lua 中的字符串能夠包含任意8-bit值，包括 '\0' 表示的零；
文字串也可由長括號的形式定義。左長括號由兩個左方括號（[[）表示，在兩個方括號之間能夠有 n 個等號（=），等號表明級別。因而，0級左長括號就寫做 [[，1級就寫做 [=[。相對應的右長括號就是 ]] 和 ]=]。這主要用於長文字串，在相同等級（就是等號同樣多）的左右長括號以內，可輸入任何文本，不處理轉義符，不受分行限制，忽略全部不對等級的嵌套長括號。任何行尾符（回車、換行、回車加換行、換行加回車）通通變成簡單的換行。
Any byte in a literal string not explicitly affected by the previous rules represents itself. However, Lua opens files for parsing in text mode, and the system file functions may have problems with some control characters. So, it is safer to represent non-text data as a quoted literal with explicit escape sequences for non-text characters.
爲了方便，左長括號後面緊跟的那個換行符將被忽略。例如，一個使用 ASCII 碼的系統中（ 'a' 編碼爲 97，\n 編碼爲 10， '1' 編碼爲 49），下面五種形式表示相同的字符串：
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]
numerical constant（數值常量） 能夠寫成普通形式，也能夠寫成科學計數法（指數部分由字母 'e' 或 'E' 標記）。Lua 也支持十六進制常量，只需前面加上 0x 或者 0X。十六進制也接受二進制指數形式的小數（用字母 'p' 或 'P 標記）。如下是一些合法的數值常量寫法：
3 3.0 3.1416 314.16e-2 0.31416E1
0xff 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1
comment（註釋） 由兩橫開始 (--)，能夠出如今字符串以外的任何地方。若是跟在 -- 後面的不是一個左長括號，這就是一個 短註釋，做用範圍直到行末。不然就是一個 長註釋，做用範圍是同等級的右長括號。長註釋經常使用於臨時屏蔽代碼塊。
3.2 – 變量
變量是存儲值的地方。Lua 中有三種：全局變量、局部變量和表的域。
一個單獨的名字能夠表示爲一個全局變量或者一個局部變量（或者一個函數參數，這也是一種局部變量）：
var ::= Name
Name 就是 §3.1所定義的標識符。
任何沒有顯示聲明爲 local （參見 §3.3.7）的變量名都可假定爲全局變量。局部變量的 lexically scoped（做用域）：定義在函數做用域（參見 §3.5）的局部變量可被其自由訪問。
變量首次賦值前，默認值均爲 nil。
方括號用於索引表：
var ::= prefixexp ‘[’ exp ‘]’
訪問表的域的含義能被元表更改。而訪問被索引的變量 t[i] 等價於調用 gettable_event(t,i)。（參見 §2.4 獲取 gettable_event 函數的完整描述。該函數未在 Lua 中定義，也不能調用。這裏僅僅用於闡述原理。）
語法 var.Name 也僅是 var["Name"] 的語法糖：
var ::= prefixexp ‘.’ Name
對全局變量 x 的訪問等價於訪問 _ENV.x。 因爲按程序塊編譯因此，_ENV 自己並非一個全局名稱 （參見 §2.2）。
3.3 – 語句
Lua 支持的常見語句相似Pascal或者C。包括賦值語句、控制語句、函數調用和變量聲明。
3.3.1 – 語句塊
一個語句塊就是一堆按順序執行的語句：
block ::= {stat}
Lua 容許 empty statements（空語句），能夠用分號隔開語句，也可用一個或者連續兩個分號來做空語句塊。
stat ::= ‘;’
左括號表示函數調用和賦值語句。這有時會讓 Lua 的語法產生歧義。好比下面這段代碼：
a = b + c
(print or io.write)('done')
有兩種語法分析方式：
a = b + c(print or io.write)('done')
a = b + c; (print or io.write)('done')
現今的語法分析器常常以第一種方式解析這類寫法。即把左括號解釋成函數調用。要避免這種歧義，最好是在那些括號開頭的語句前面寫個分號：
;(print or io.write)('done')
一個語句塊也能夠用下面的方式寫成一條語句（寫在 do 和 end 之間）：
stat ::= do block end
顯示的語句塊對控制變量的做用域頗有用。有時也用於在其餘語句塊中插入 return 語句（參見see §3.3.4）。
3.3.2 – 程序塊
chunk（程序塊）就是 Lua 中的編譯單元。從語法上講，程序塊就是簡單的語句塊。
chunk ::= block
Lua 將程序塊看成一個擁有可變參數的匿名函數來處理（參見 §3.4.10）。因此，程序塊能夠定義局部變量、接收參數並返回值。此外，這樣的匿名函數被編譯在一個叫 _ENV （參見 §2.2）的外部局部變量的做用域內。產生的函數經常使用 _ENV 做爲惟一的自由變量，即使根本沒用它。（譯者注：說白了就是程序塊至關於匿名函數，這些函數默認處於 _ENV 的命名空間中，使用時要寫成 _ENV.*****。）
程序塊能夠存在單獨的文件中，也可直接寫在宿主程序的一個字符串中。執行程序塊時，Lua 現將它預編譯成虛擬機指令，而後由虛擬機的解釋器來執行這些指令。
程序塊也可被預編譯成二進制形式；詳情查閱程序 luac。源碼形式和二進制形式的程序能夠相互轉換；Lua 會自動識別文件類型並作正確處理。
3.3.3 – 賦值
Lua 容許多重賦值。所以，賦值的語法規定等號左邊是一串變量，右邊是一串表達式。串中的元素用等號隔開：
stat ::= varlist ‘=’ explist
varlist ::= var {‘,’ var}
explist ::= exp {‘,’ exp}
表達式放在 §3.4 討論。
賦值以前，會先根據左邊變量的數量對右邊值的數量進行調整。值多了，多餘的將被丟棄；值少了，用 nil 補齊。若是右邊最後是一個函數調用結尾，則在數量對齊以前用該函數的所有返回值替換它（除非函數調用位於括號內：參見 §3.4）。
賦值語句會首先執行全部表達式（兩邊），而後作純粹的賦值。所以，下面這段代碼
i = 3
i, a[i] = i+1, 20
把 a[3] 賦值爲20而不是影響 a[4]，由於 a[i] 中的 i 在賦值爲4以前已經肯定（爲3）。一樣，這一行
x, y = y, x
能用來交換 x 和 y的值，並且
x, y, z = y, z, x
能循環交換 x，y，z 的值。
對全局變量和表的域賦值的含義能經過元表進行更改。對索引變量賦值，即 t[i] = val 等價於 settable_event(t,i,val)。（參見 §2.4 獲取 settable_event 函數的完整描述。Lua 中並無定義該函數，也不能調用。這裏僅用於闡述原理。）
對全局變量賦值 x = val 等價於 _ENV.x = val （參見 §2.2）。
3.3.4 – 控制結構
if、while 和 repeat 等結構的意義和語法都很常見：
stat ::= while exp do block end
stat ::= repeat block until exp
stat ::= if exp then block {elseif exp then block} [else block] end
Lua 也有 for 語句，並有兩種形式（參見 §3.3.5）。
控制結構中的條件表達式能夠返回任何值。只有 false 和 nil 才被看成條件假。其餘任何值都被看成條件真（尤爲注意數字 0 和空字符串也爲真）。
在 repeat–until 循環中，內部語句不在 until 關鍵字處結束，而是在條件後面結束。因此，條件中可使用循環體內聲明的局部變量。
goto 語句能將程序控制轉移到一個標籤處。從語法上講，Lua 中的標籤也被看成是語句：
stat ::= goto Name stat ::= label label ::= ‘::’ Name ‘::’
標籤在被定義的語句塊內所有可見，除非在某個嵌套語句塊的嵌套函數內定義了一個同名的標籤。一個 goto 只要不進入局部變量做用域，它能跳轉到任意可見的標籤上。
標籤可空語句叫做 void statements，表示它們自己沒有任何行爲。
break 語句用於終止 while、repeat 或 for 循環，並忽略循環體中剩下的語句：
stat ::= break
break 能結束內層循環。
return 語句用於從函數或程序塊（假裝成函數）中返回值。 函數能夠返回多個值。因此 return 語句的語法是：
stat ::= return [explist] [‘;’]
return 語句只能寫做語句塊的最後一句。若是在語句塊中間確實須要 return，得顯示使用內部語句塊。習慣寫成 do return end，因而這個return 在內層語句塊中成了最後一句（這徹底符合前面的規定）。
3.3.5 – For 語句
for 語句有兩種形式：數字形式和通常形式。
數字形式的 for 循環，控制量以等差數列變化來重複運行代碼塊。語法以下：
stat ::= for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end
block 從 name 等於第一個 exp 開始重複運行。不斷以第三個 exp 做爲步長直到等於第二個 exp 才中止循環。更準確的說，一條 for 語句相似於：
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、limit和step都是不可見變量。這裏的名字僅用做解釋說明。- 若是省略第三個表達式（步長），則步長默認爲 1.
- 可使用 break 來跳出 for 循環。
- 循環量
v是循環內部的局部變量：不能在 for 循環結束或跳出後繼續使用它的值。若是確實須要該值，請在循環退出或跳出以前把值賦給另外的變量。
通常形式的 for 語句經過叫 iterators（迭代器） 的函數工做。每一次迭代，都會調用迭代器來產生一個新值。當新值爲 nil 時，循環中止。通常形式的 for 循環語法以下：
stat ::= for namelist in explist do block end
namelist ::= Name {‘,’ Name}
一條 for 語句相似於
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)
if var_1 == nil then break end
var = var_1
block
end
end
注意事項：
explist僅被求值一次。其結果有三：一個 iterator（迭代器） 函數，一個 state（狀態）和首個 iterator variable（迭代量）的初始值。f、s和var都是不可見變量。這裏的名字僅用做解釋說明。- 可使用 break 來跳出 for 循環。
- 循環量
var_i是循環體內的局部變量：不能在 for 循環結束後繼續使用它的值。若是確實須要該值，請在循環退出或跳出以前把值賦給另外的變量。
3.3.6 – 函數調用做爲語句
爲了容許使用可能的反作用，函數調用可看成語句執行：
stat ::= functioncall
這種狀況下，全部的返回值均被丟棄。關於函數調用的說明在 §3.4.9。
3.3.7 – 局部聲明
局部變量可在語句塊內任何地方聲明。聲明的同時能夠進行初始化賦值操做：
stat ::= local namelist [‘=’ explist]
若是作了，初始化賦值操做在語法上等同於多重賦值（see §3.3.3）。不然，全部變量均被初始化爲 nil。
程序塊也是語句塊（參見 §3.3.2），所以局部變量可在任何顯示語句塊以外的程序塊中聲明。
局部變量的可見性規則在 §3.5 說明。
3.4 – 表達式
Lua 中的基本表達式以下：
exp ::= prefixexp exp ::= nil | false | true exp ::= Number exp ::= String exp ::= functiondef exp ::= tableconstructor exp ::= ‘...’ exp ::= exp binop exp exp ::= unop exp prefixexp ::= var | functioncall | ‘(’ exp ‘)’
數字和文字串的說明在 §3.1； 變量的說明在 §3.2； 函數定義的介紹在 §3.4.10； 函數調用的說明在 §3.4.9； 表的構造器在 §3.4.8。 由三點（'...'）表示的可變參數表達式只能用於有可變參數的函數中：詳見 §3.4.10。
二元運算包括算術運算（§3.4.1）、關係運算（§3.4.3）、邏輯運算（§3.4.4）以及鏈接運算（§3.4.5）。一元運算包括取負（§3.4.1）、not（§3.4.4）和 取長度 （§3.4.6）。
函數調用和參數可變的表達式都可返回多個值。若是將函數調用做爲一條語句使用（參見§3.3.6），則其返回值列表與0對齊，即丟棄全部返回值。若是一個表達式是一串表達式中最後的/惟一的元素，則不會有對齊操做（除非該表達式位於括號內）。在其餘狀況，Lua 會將返回結果表與1對齊，即丟棄第一個返回值外的其餘值；若是沒有返回值，Lua 自動添加一個 nil。
如下是一些示例：
f() -- 調整成 返回0 個結果
g(f(), x) -- f() 被調整成返回 1 個結果
g(x, f()) -- g 被傳入 x 和全部 f() 返回值
a,b,c = f(), x -- f() 被調整成返回 1 個結果（c 就成了 nil）
a,b = ... -- a 被賦值爲可變參數中的第一個，
-- b 爲第二個（若是可變參數沒有對應參數，a 和 b 都爲 nil ）
a,b,c = x, f() -- f() 被調整成返回 2 個結果
a,b,c = f() -- f() 被調整成返回 3 個結果
return f() -- 返回 f() 全部結果
return ... -- 返回可變參數接收到的全部參數
return x,y,f() -- 返回 x、y、和全部 f() 返回值
{f()} -- 爲 f() 的全部返回值建立一個列表
{...} -- 爲可變參數接收到的全部參數建立一個列表
{f(), nil} -- f() 被調整成返回 1 個結果
任何由括號括起來的表達式只被當成一個值。所以，(f(x,y,z)) 永遠都只能是個單值，即便 f 返回了多個值。（(f(x,y,z)) 的值是 f 返回的第一個值；若是 f 沒有返回值，則爲 nil。）
3.4.1 – 算術運算符
Lua 支持經常使用算術運算符： +（加）、-（減）、*（乘）、/（除）、%（取模）和 ^（冪）；還有一元-（取負）操做。若是運算對象是數字，或是可轉換爲數字的字符串（參見 §3.4.2），那就是單純的數學運算。求冪操做可用於任何指數，好比 x^(-0.5) 計算出 x 平方根的倒數。取模操做的定義是
a % b == a - math.floor(a/b)*b
That is, it is the remainder of a division that rounds the quotient towards minus infinity.
3.4.2 – 強制轉換
Lua 在運行時提供字符串與數字之見的自動轉換。在 Lua 的詞法分析下，任何適用字符串的算術運算都會嘗試把字符串轉化爲數字。（字符串首尾可能有空白和標記。）反過來，任何須要字符串的時候，數字就會被轉化成字符串。想要徹底掌控數字轉化字符串，可使用 string 庫中的 format 函數（參見 string.format）。
3.4.3 – 關係運算符
Lua 中的關係運算符有
== ~= < > <= >=
運算結果爲 false 或者 true.
相等判斷（==）首先比較運算對象的類型。若是類型不一樣，則結果爲 false。不然才比較對象的值。數字、字符串用常規方式比較。而表、用戶數據和線程得靠引用來比較：兩個對象只在指向（引用）同一個對象才判爲相等。每一次建立的新對象（表、用戶數據或者線程）都與前面存在的對象不一樣。對相同引用的閉包互相相等。而任何可檢測出不一樣（行爲不一樣、定義不一樣）的閉包天然也不相等。
固然，你可使用 "eq" 元方法（參見 §2.4）來改變表與用戶數據的比較操做。
§3.4.2 的轉換規則不適用於相等性判斷操做。所以， "0"==0 值爲 false。t[0] 和 t["0"] 表明的是表中不一樣的元素。
~= 操做符恰好與 == 意義相反。
大小比較的規則以下：若是比較參數都爲數字，則作數字比較；若是都爲字符串，則按字符串比較規則進行；不然，Lua 就嘗試使用 "lt" 或 "le" 元方法（參見 §2.4）。a > b 被翻譯成 b < a，a >= b 被翻譯成 b <= a。
3.4.4 – 邏輯運算符
Lua 中的邏輯運算符有 and、or、和 not。相似控制結構（參見 §3.3.4），全部的邏輯操做符只將 false 和 nil 看成假，其餘全部狀況都爲真。
取反操做 not 只返回 false 或者 true。與操做 and 在第一個參數爲 false 或 nil 時返回第一個參數，不然返回第二個參數。或操做 or 在第一個參數不是 nil 和 false 時返回第一個參數。不然返回第二個參數。and 和 or 都使用短路求值法；意思是第二個參數只在必要時才求值。下面是些例子：
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
（本手冊中的 --> 符號指代前面表達式的結果。）
3.4.5 – 鏈接操做
Lua 使用兩個點（'..'）表示字符串鏈接操做。若是操做對象是字符串和數字，則會按照 §3.4.2 提到的規則將他們轉化爲字符串。否則就調用 __concat 元方法（參見 §2.4）。
3.4.6 – 取長度操做符
取長度的操做符是一元運算符 #。字符串的長度是其字節數（就是一個字符表示一個字節算出的長度）。
程序裏可經過 __len 元方法（參見 §2.4）來修改除字符串外全部值的取長度操做行爲。
除了已知的 __len 元方法，表 t 的長度只在它是順序表時有定義。並且其鍵值要按 {1..n} 遞增，則整數 n 就是長度。注意像下面這樣的表
{10, 20, nil, 40}
不是順序表，由於它有第 4 個鍵，卻沒有第 3 個鍵。而非數字鍵則不影響判斷表是否爲順序表。
3.4.7 – 優先級
Lua 中操做符優先級以下表所示，從低到高排列：
or
and
< > <= >= ~= ==
..
+ -
* / %
not # - (unary)
^
一般，能夠在表達式中使用括號來改變優先級。鏈接符（'..'）和求冪（'^'）從右往左結合。其餘二元運算符是從左往右的。
3.4.8 – 表的構造器
表的構造器是一對用於建立表的表達式。每執行一次構造器就建立一張新表。構造器可用於建立空表或者建立的同時初始化一些域。構造器的語法以下：
tableconstructor ::= ‘{’ [fieldlist] ‘}’
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp
fieldsep ::= ‘,’ | ‘;’
每個 [exp1] = exp2 形式的域都將爲新表加入一個鍵爲 exp1 值爲 exp2 的元素。name = exp 形式的域等價於 ["name"] = exp。而 exp 形式的域等價於 [i] = exp，其中的 i 爲從 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
若是列表中最後一個域形式爲 exp，並且這個表達式是個函數調用或者參數可變，那麼表達式的全部返回值將按順序插入列表（參見 §3.4.9）。
域的列表能夠有一個可選的尾部分隔符，這樣方便機器生成代碼。
3.4.9 – 函數調用
Lua 中的函數調用語法以下：
functioncall ::= prefixexp args
在函數調用中，首先對 prefixexp 和 args 求值。若是 prefixexp 的值的也是 function（函數），則用相應參數調用該函數。不然，調用 prefixexp 的 "call" 元方法，並將 prefixexp 的值做第一個參數，再跟其餘原始參數（參見 §2.4）。
這種形式
functioncall ::= prefixexp ‘:’ Name args
能夠用來調用「方法」。 v.name(v,args) 只在 v 僅被求值一次的時候能夠寫成 v:name(args)，這種寫法只是語法糖便利。
參數的語法以下：
args ::= ‘(’ [explist] ‘)’ args ::= tableconstructor args ::= String
全部參數表達式都在函數調用以前被求值。f{fields} 形式的函數調用也只是 f({fields}) 形式的語法糖寫法；即參數列表是個新表。而 f'string' （或者 f"string" 或者f[[string]]）一類的調用形式也只是 f('string') 的語法糖寫法；即參數表是單一的文字串。
Lua 中將 return functioncall 這種形式叫 tail call（尾調用）。Lua 實現的是徹底尾調用（也叫徹底尾遞歸）：在尾調用中，被調用的函數重用調用它的函數的堆棧。所以，程序可執行的嵌套尾調用沒有層數限制（即無限尾調用）。而尾調用也會刪除任何關於調用它的函數的調試信息。注意，尾調用只能出如今特殊的語法下：return 只有一個函數做爲參數；這使得調用函數能明確返回被調函數的結果。因此，下面這些都不是尾調用：
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
3.4.10 – 函數定義
函數定義的語法以下：
functiondef ::= 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 時纔有點區別。）
函數定義是一個可執行表達式，執行結果是個類型爲 function的值。Lua 預編譯 chunk（程序塊）時，它的全部函數體也會被預編譯。每當 Lua 執行函數定義，函數才被 instantiated（實例化）（也叫 closed（閉合））。這個函數實例（也叫closure（閉包））纔是表達式最終的值。
形參（函數定義的參數）做爲局部變量由實參（函數調用時傳入的參數）的值初始化：
parlist ::= namelist [‘,’ ‘...’] | ‘...’
調用函數時，實參列表會根據形參列表的長度作調整，除非趕上了形參列表以三點（'...'）結尾的 vararg function（變參函數）。變參函數不會調整實參列表，而是收集全部額外的實參而後經過 vararg expression（變參表達式）（也寫成 '...'）傳給函數。變參表達式的值就是包含所有額外實參的列表，這相似返回多值的函數。若是變參表達式在另外一個表達式中使用，或者是位於一堆表達式的中間，那麼它返回的值會被調整成單個元素。而如果該表達式是那堆表達式的最後一個，那就不用作調整了（除非最後的表達式位於括號以內）。
先看下面這個函數定義的例子：
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
return 語句用於返回結果（參見 §3.3.4）。若是執行到函數結尾沒發現一個 return 語句，則函數沒有結果返回。
一個函數能返回的結果數量因系統不一樣而限制不一樣，但確定大於1000。
colon（冒號） 語法用於定義 methods（方法）。意思是函數有一個額外的隱式參數 self。因此，以下語句
function t.a.b.c:f (params) body end
是以下寫法的語法糖（簡寫）形式
t.a.b.c.f = function (self, params) body end
3.5 – 可見性規則
Lua 是門有詞法域的語言。一個局部變量的做用域開始於聲明後的第一條語句，結束於包含該聲明的最內層語句塊中的最後一條非空語句。思考下面的例子：
x = 10 -- 全局變量
do -- 新語句塊開始
local x = x -- 新的 'x'，值爲 10
print(x) --> 10
x = x+1
do -- 另外一個語句塊開始
local x = x+1 -- 另外一個 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10（此爲全局的那一個）
留心注意，相似 local x = x 的聲明，新聲明的 x 還不在做用域內（譯者注：做用域開始於聲明語句的下一句，不包括聲明語句自己），因此後面的 x 仍是指那個外層變量。
由於有詞法域規則，因此函數可隨意訪問定義在其做用域內的局部變量。局部變量被更內層的函數使用，則稱其爲 upvalue，或者是 external local variable（外層局部變量）。
要注意，每執行一次 local 語句都會定義新的局部變量。思考下面的例子：
a = {}
local x = 20
for i=1,10 do
local y = 0
a[i] = function () y=y+1; return x+y end
end
這個循環建立了十個 closures（閉包，這裏指十個匿名函數實例）。每個 closure 使用的都是不一樣的 y ，相同的 x。
4 – 應用程序接口（API）
本章描述 Lua 中的 C API，就是那些用於宿主程序和 Lua 通信的 C 函數。全部 API 函數和相關的類型/常量定義都在 lua.h 頭文件中。
雖然咱們說的是「函數」，但某些 API 實際上是以宏的形式提供的。除非特別說明，全部這些宏對它們的參數都只使用一次（除了常爲 Lua 狀態機的第一個參數），因此不用擔憂這些宏的展開會隱藏一些反作用。
在大部分 C 庫中，Lua 的 API 函數都不會檢查參數的有效性和一致性。但你能夠在編譯 Lua 時經過內置的宏 LUA_USE_APICHECK 來改變這個設定。
4.1 – 棧
Lua 使用一個 virtual stack（虛擬棧） 來與 C 傳遞值。棧內每一個元素都表明一個 Lua 值（nil、數字、字符串等等）。
任什麼時候候 Lua 調用 C 函數，被調函數都會得到一個新棧。該棧獨立於之前的棧，也獨立於函數在 C 中的棧。這個棧初始時包含傳遞給 C 函數的全部參數，而後 C 函數把要返回給調用者的結果也壓入其中（參見 lua_CFunction）。
爲方便起見，API 中大部分查詢操做都不嚴格遵照常規棧的規則。而是能夠經過一個 index 來索引棧中任意元素。一個正的索引值表示了棧中的絕對位置（從 1 開始）；負的索引值表示了相對棧頂的偏移量。具體來講，若是棧有 n 個元素，則索引 1 表明第一個元素（就是第一個壓入棧的元素，在棧底），索引 n 表明最後一個元素；而索引 -1 也表明最後一個元素（就是棧頂元素），索引 -n 表明第一個元素。
4.2 – 棧大小
與 Lua 交互時，要負責確保一致性。尤爲要 負責控制棧的溢出狀況。在壓棧前可使用函數 lua_checkstack 來檢查棧中是否擁有足夠的位置。
Lua 不管什麼時候調用 C，它都確保棧至少擁有 LUA_MINSTACK 個位置。LUA_MINSTACK 被定義爲 20。因此，只要不是循環壓棧，一般無需擔憂棧空間。
調用一個返回結果數量不定的 Lua 函數（參見 lua_call）時，Lua 會確保棧空間足夠容納全部返回結果，但不確保還有更多額外空間。因此，在調用了這種函數後，繼續壓棧前最好使用lua_checkstack 檢查一下棧空間。
4.3 – 有效索引與合格索引
API 中的任何能接受棧索引的函數只接受 valid indices（有效索引） 或 acceptable indices（合格索引）。
有效索引 指的是指向棧內真實位置的索引，意思是其值在 1 和棧頂之間（即1 ≤ abs(index) ≤ top）。一般，函數要修改某個索引項的值時就要求有效索引。
除非另有提示，任何接受有效索引的函數同時也接受 pseudo-indices（僞索引），幫助 C 代碼訪問一些不在棧內的 Lua 值。僞索引可用於訪問註冊表和 C 函數的 upvalues（參見 §4.4）。
那種不需具體位置只要棧內一個值的函數（好比，查詢函數）能夠用合格索引進行調用。一個 acceptable index（合格索引） 可爲任意有效索引，包括僞索引，也可爲棧空間內棧頂以後的任和正索引，意味着索引值最大爲棧的大小。（注意，0 歷來都不是合格索引。）除非特殊說明，API 中的函數只在合格索引下有效工做。
合格索引在查詢棧的時候避免了額外的棧頂判斷。例如，一個 C 函數能夠查詢它的第三個參數而沒必要先檢查是否存在第三個參數，意思是沒必要檢查索引 3 是否有效。
對於那些能用合格索引調用的函數，任何無效索引都被看成成包含一個虛擬類型爲 LUA_TNONE 的值，其行爲相似一個 nil 值。
4.4 – C Closures（閉包）
建立一個 C 函數時，可能會關聯一些值，所以就建立了一個 C closure（參見 lua_pushcclosure），那些值就叫 upvalues，而且可在函數被調用時訪問到。
每當調用 C 函數時，它的 upvalue 就被放在特定的僞索引處。這些僞索引由宏 lua_upvalueindex 產生。與函數相關的第一個值在 lua_upvalueindex(1) 處，並依此類推。當 n 大於當前函數中 upvalue 的數量（小於 256）時， lua_upvalueindex(n) 將產生合格但無效的索引值。
4.5 – 註冊表
Lua 提供一個 registry（註冊表），是一張用於 C 代碼保存所需 Lua 值的預約義表。註冊表位於僞索引 LUA_REGISTRYINDEX 處，這是一個有效索引。任何 C 庫均可以向表中保存數據，只是在選擇鍵的時候要避免和其餘庫衝突。通常來講，能夠用包含庫名的字符串，或者用代碼中一個 C 對象的地址作成的簡易 userdata，或者用代碼中建立的任意 Lua 對象。（譯者注：鍵的形式很隨意，不侷限於字符串，可詳細參考 table 類型。）與全局變量同樣，如下劃線開頭跟大寫字母的字符串鍵是爲 Lua 保留的。
註冊表內的整數鍵用做引用機制，在輔助庫中實現時也使用一些預約義值。所以，整數鍵不能作他用。
建立一個新的 Lua 狀態機時，它的註冊表來自於一些預約義的值。這些預約義值做爲常量定義在 lua.h，由整數鍵進行索引。 下面的常量定義：
4.6 – C 中的錯誤處理
在內部實現中，Lua 使用 C 的 longjmp 機制來處理錯誤。（若是 Lua 和 C++ 編譯，也能夠選擇使用異常；查閱源碼內的 LUAI_THROW。）Lua 面對任何錯誤（好比內存分配錯誤、類型錯誤、語法錯誤和運行時錯誤）都會產生一個錯誤；就是作一個 long jump。在 protected environment（保護環境）下使用 setjmp 能夠設置一個恢復點；任何錯誤都會跳轉到最近活動的恢復點上。
若是錯誤發生在保護環境以外，Lua 會調用一個 panic 函數（參見 lua_atpanic），而後調用 abort來退出宿主程序。panic 函數也能夠不返回來避免這種退出（好比，作一個 long jump 跳轉到 Lua 以外你本身的恢復點上）。
panic 函數運行起來就像一個消息處理器（參見 §2.3）；尤爲是錯誤消息位於棧頂時。問題在於無法保證棧的空間。向棧內壓入任何東西，panic 函數都須要先檢查可用空間（參見 §4.2）。
API 中大部分函數都能拋出錯誤，好比內存分配錯誤。每一個函數的文檔內具體指示了它是否能拋出錯誤。
在 C 函數內能夠經過調用 lua_error 來拋出一個錯誤。
4.7 – C 中的掛起處理
在內部實現中，Lua 使用 C的 longjmp 機制來掛起協程。所以，若是函數 foo 調用一個 API 函數，而該 API 函數掛起了（直接或間接掛起），Lua 無法給 foo 返回任何東西，由於 longjmp已將它的 frame 從 C 棧中移除了。
爲避免這類問題，每當穿過 API 調用而掛起時 Lua 都會彈出錯誤，只除了這三個函數：lua_yieldk、lua_callk 和 lua_pcallk。這三個函數接收一個 continuation function（繼續函數）（有一個參數叫 k）用於掛起後繼續執行。
咱們須要用一些術語來解釋這個 continuation。首先，咱們有一個由 Lua 調用的 C 函數，它叫 original function（原始函數）。這個原始函數隨後在 C API 內調用了前面三個函數中的一個，叫callee function（被調函數），而後當前線程被掛起。（掛起可能發生在被調函數是 lua_yieldk時，或者被調函數是 lua_callk 或 lua_pcallk兩者其一併且被本身掛起。）
假定是在執行被調函數時運行的線程被掛起。等線程恢復後，它最終會結束運行被調函數。然而，被調函數此時卻無法返回給原始函數，由於它在 C 棧中的 frame 在掛起時給銷燬了。因而，Lua 調用看成參數傳遞給被調函數的 continuation function（繼續函數）。顧名思義，繼續函數能夠繼續原始函數的工做。
Lua 將繼續函數看做原始函數。繼續函數接收來源於原始函數的相同 Lua 棧，在被調函數返回後也（與原始函數）處於同樣的狀態。（例如，lua_callk 調用一個函數後，它的參數均從棧中移除並被替換成那個函數的返回結果。）繼續函數也擁有相同的 upvalue。不管繼續函數返回什麼值，都會被 Lua 看成是由原始函數返回的同樣進行處理。
在 Lua 狀態機中，原始函數與它的繼續函數惟一的不一樣就是 lua_getctx 返回結果的不一樣。
4.8 – 函數與類型
咱們在這兒按字母順序列出 C API 中全部的函數與類型。每個函數都有一個相似右邊這樣的標記：[-o, +p, x]
第一個字段，o，表示函數從棧中彈出多少個元素。
第二個字段，p，表示函數向棧壓入多少個元素。（全部函數都會在彈出參數後再壓入結果。）形如 x|y 這樣的字段表示函數能夠壓入（彈出） x 或 y 個元素，由具體狀況決定；而問號 '?' 表示咱們沒法只經過觀察參數來得知函數彈出/壓入多少個元素（好比，它們依賴與棧中的內容）。
第三個字段，x，用於告知函數是否拋出錯誤： '-' 表示從不拋出任何錯誤；'e' 表示可能拋出錯誤；'v' 表示有目的地拋出一個錯誤。
lua_absindex
[-0, +0, –]
int lua_absindex (lua_State *L, int idx);
將合格索引 idx 轉化爲一個絕對索引（就是不依賴棧頂）。
lua_Alloc
typedef void * (*lua_Alloc) (void *ud,
void *ptr,
size_t osize,
size_t nsize);
The type of the memory-allocation function used by Lua states. The allocator function must provide a functionality similar to realloc, but not exactly the same. Its arguments are ud, an opaque pointer passed to lua_newstate; ptr, a pointer to the block being allocated/reallocated/freed; osize, the original size of the block or some code about what is being allocated; nsize, the new size of the block.
When ptr is not NULL, osize is the size of the block pointed by ptr, that is, the size given when it was allocated or reallocated.
When ptr is NULL, osize encodes the kind of object that Lua is allocating. osize is any of LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, or LUA_TTHREAD when (and only when) Lua is creating a new object of that type. When osize is some other value, Lua is allocating memory for something else.
Lua assumes the following behavior from the allocator function:
When nsize is zero, the allocator should behave like free and return NULL.
When nsize is not zero, the allocator should behave like realloc. The allocator returns NULL if and only if it cannot fulfill the request. Lua assumes that the allocator never fails when osize >= nsize.
Here is a simple implementation for the allocator function. It is used in the auxiliary library by 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);
}
Note that Standard C ensures that free(NULL) has no effect and that realloc(NULL, size) is equivalent to malloc(size). This code assumes that realloc does not fail when shrinking a block. (Although Standard C does not ensure this behavior, it seems to be a safe assumption.)
lua_arith
[-(2|1), +1, e]
void lua_arith (lua_State *L, int op);
Performs an arithmetic operation over the two values (or one, in the case of negation) at the top of the stack, with the value at the top being the second operand, pops these values, and pushes the result of the operation. The function follows the semantics of the corresponding Lua operator (that is, it may call metamethods).
The value of op must be one of the following constants:
LUA_OPADD: performs addition (+)LUA_OPSUB: performs subtraction (-)LUA_OPMUL: performs multiplication (*)LUA_OPDIV: performs division (/)LUA_OPMOD: performs modulo (%)LUA_OPPOW: performs exponentiation (^)LUA_OPUNM: performs mathematical negation (unary-)
lua_atpanic
[-0, +0, –]
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
Sets a new panic function and returns the old one (see §4.6).
lua_call
[-(nargs+1), +nresults, e]
void lua_call (lua_State *L, int nargs, int nresults);
Calls a function.
To call a function you must use the following protocol: first, the function to be called is pushed onto the stack; then, the arguments to the function are pushed in direct order; that is, the first argument is pushed first. Finally you call lua_call; nargs is the number of arguments that you pushed onto the stack. All arguments and the function value are popped from the stack when the function is called. The function results are pushed onto the stack when the function returns. The number of results is adjusted to nresults, unless nresults is LUA_MULTRET. In this case, all results from the function are pushed. Lua takes care that the returned values fit into the stack space. The function results are pushed onto the stack in direct order (the first result is pushed first), so that after the call the last result is on the top of the stack.
Any error inside the called function is propagated upwards (with a longjmp).
The following example shows how the host program can do the equivalent to this Lua code:
a = f("how", t.x, 14)
Here it is in C:
lua_getglobal(L, "f"); /* function to be called */
lua_pushstring(L, "how"); /* 1st argument */
lua_getglobal(L, "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_setglobal(L, "a"); /* set global 'a' */
Note that the code above is "balanced": at its end, the stack is back to its original configuration. This is considered good programming practice.
lua_callk
[-(nargs + 1), +nresults, e]
void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
lua_CFunction k);
This function behaves exactly like lua_call, but allows the called function to yield (see §4.7).
lua_CFunction
typedef int (*lua_CFunction) (lua_State *L);
Type for C functions.
In order to communicate properly with Lua, a C function must use the following protocol, which defines the way parameters and results are passed: a C function receives its arguments from Lua in its stack in direct order (the first argument is pushed first). So, when the function starts, lua_gettop(L) returns the number of arguments received by the function. The first argument (if any) is at index 1 and its last argument is at index lua_gettop(L). To return values to Lua, a C function just pushes them onto the stack, in direct order (the first result is pushed first), and returns the number of results. Any other value in the stack below the results will be properly discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.
As an example, the following function receives a variable number of numerical arguments and returns their average and sum:
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);
Ensures that there are at least extra free stack slots in the stack. It returns false if it cannot fulfill the request, because it would cause the stack to be larger than a fixed maximum size (typically at least a few thousand elements) or because it cannot allocate memory for the new stack size. This function never shrinks the stack; if the stack is already larger than the new size, it is left unchanged.
lua_close
[-0, +0, –]
void lua_close (lua_State *L);
Destroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by this state. On several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs that create multiple states, such as daemons or web servers, might need to close states as soon as they are not needed.
lua_compare
[-0, +0, e]
int lua_compare (lua_State *L, int index1, int index2, int op);
Compares two Lua values. Returns 1 if the value at index index1 satisfies op when compared with the value at index index2, following the semantics of the corresponding Lua operator (that is, it may call metamethods). Otherwise returns 0. Also returns 0 if any of the indices is non valid.
The value of op must be one of the following constants:
LUA_OPEQ: compares for equality (==)LUA_OPLT: compares for less than (<)LUA_OPLE: compares for less or equal (<=)
lua_concat
[-n, +1, e]
void lua_concat (lua_State *L, int n);
Concatenates the n values at the top of the stack, pops them, and leaves the result at the top. If n is 1, the result is the single value on the stack (that is, the function does nothing); if n is 0, the result is the empty string. Concatenation is performed following the usual semantics of Lua (see §3.4.5).
lua_copy
[-0, +0, –]
void lua_copy (lua_State *L, int fromidx, int toidx);
Moves the element at index fromidx into the valid index toidx without shifting any element (therefore replacing the value at that position).
lua_createtable
[-0, +1, e]
void lua_createtable (lua_State *L, int narr, int nrec);
Creates a new empty table and pushes it onto the stack. Parameter narr is a hint for how many elements the table will have as a sequence; parameter nrec is a hint for how many other elements the table will have. Lua may use these hints to preallocate memory for the new table. This pre-allocation is useful for performance when you know in advance how many elements the table will have. Otherwise you can use the function lua_newtable.
lua_dump
[-0, +0, e]
int lua_dump (lua_State *L, lua_Writer writer, void *data);
Dumps a function as a binary chunk. Receives a Lua function on the top of the stack and produces a binary chunk that, if loaded again, results in a function equivalent to the one dumped. As it produces parts of the chunk, lua_dump calls function writer (see lua_Writer) with the given data to write them.
The value returned is the error code returned by the last call to the writer; 0 means no errors.
This function does not pop the Lua function from the stack.
lua_error
[-1, +0, v]
int lua_error (lua_State *L);
Generates a Lua error. The error message (which can actually be a Lua value of any type) must be on the stack top. This function does a long jump, and therefore never returns (seeluaL_error).
lua_gc
[-0, +0, e]
int lua_gc (lua_State *L, int what, int data);
Controls the garbage collector.
This function performs several tasks, according to the value of the parameter what:
LUA_GCSTOP: stops the garbage collector.LUA_GCRESTART: restarts the garbage collector.LUA_GCCOLLECT: performs a full garbage-collection cycle.LUA_GCCOUNT: returns the current amount of memory (in Kbytes) in use by Lua.LUA_GCCOUNTB: returns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.LUA_GCSTEP: performs an incremental step of garbage collection. The step "size" is controlled bydata(larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value ofdata. The function returns 1 if the step finished a garbage-collection cycle.LUA_GCSETPAUSE: setsdataas the new value for the pause of the collector (see §2.5). The function returns the previous value of the pause.LUA_GCSETSTEPMUL: setsdataas the new value for the step multiplier of the collector (see §2.5). The function returns the previous value of the step multiplier.LUA_GCISRUNNING: returns a boolean that tells whether the collector is running (i.e., not stopped).LUA_GCGEN: changes the collector to generational mode (see §2.5).LUA_GCINC: changes the collector to incremental mode. This is the default mode.
For more details about these options, see collectgarbage.
lua_getallocf
[-0, +0, –]
lua_Alloc lua_getallocf (lua_State *L, void **ud);
Returns the memory-allocation function of a given state. If ud is not NULL, Lua stores in *ud the opaque pointer passed to lua_newstate.
lua_getctx
[-0, +0, –]
int lua_getctx (lua_State *L, int *ctx);
This function is called by a continuation function (see §4.7) to retrieve the status of the thread and a context information.
When called in the original function, lua_getctx always returns LUA_OK and does not change the value of its argument ctx. When called inside a continuation function, lua_getctxreturns LUA_YIELD and sets the value of ctx to be the context information (the value passed as the ctx argument to the callee together with the continuation function).
When the callee is lua_pcallk, Lua may also call its continuation function to handle errors during the call. That is, upon an error in the function called by lua_pcallk, Lua may not return to the original function but instead may call the continuation function. In that case, a call to lua_getctx will return the error code (the value that would be returned by lua_pcallk); the value ofctx will be set to the context information, as in the case of a yield.
lua_getfield
[-0, +1, e]
void lua_getfield (lua_State *L, int index, const char *k);
Pushes onto the stack the value t[k], where t is the value at the given index. As in Lua, this function may trigger a metamethod for the "index" event (see §2.4).
lua_getglobal
[-0, +1, e]
void lua_getglobal (lua_State *L, const char *name);
Pushes onto the stack the value of the global name.
lua_getmetatable
[-0, +(0|1), –]
int lua_getmetatable (lua_State *L, int index);
Pushes onto the stack the metatable of the value at the given index. If the value does not have a metatable, the function returns 0 and pushes nothing on the stack.
lua_gettable
[-1, +1, e]
void lua_gettable (lua_State *L, int index);
Pushes onto the stack the value t[k], where t is the value at the given index and k is the value at the top of the stack.
This function pops the key from the stack (putting the resulting value in its place). As in Lua, this function may trigger a metamethod for the "index" event (see §2.4).
lua_gettop
[-0, +0, –]
int lua_gettop (lua_State *L);
Returns the index of the top element in the stack. Because indices start at 1, this result is equal to the number of elements in the stack (and so 0 means an empty stack).
lua_getuservalue
[-0, +1, –]
void lua_getuservalue (lua_State *L, int index);
Pushes onto the stack the Lua value associated with the userdata at the given index. This Lua value must be a table or nil.
lua_insert
[-1, +1, –]
void lua_insert (lua_State *L, int index);
Moves the top element into the given valid index, shifting up the elements above this index to open space. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.
lua_Integer
typedef ptrdiff_t lua_Integer;
The type used by the Lua API to represent signed integral values.
By default it is a ptrdiff_t, which is usually the largest signed integral type the machine handles "comfortably".
lua_isboolean
[-0, +0, –]
int lua_isboolean (lua_State *L, int index);
Returns 1 if the value at the given index is a boolean, and 0 otherwise.
lua_iscfunction
[-0, +0, –]
int lua_iscfunction (lua_State *L, int index);
Returns 1 if the value at the given index is a C function, and 0 otherwise.
lua_isfunction
[-0, +0, –]
int lua_isfunction (lua_State *L, int index);
Returns 1 if the value at the given index is a function (either C or Lua), and 0 otherwise.
lua_islightuserdata
[-0, +0, –]
int lua_islightuserdata (lua_State *L, int index);
Returns 1 if the value at the given index is a light userdata, and 0 otherwise.
lua_isnil
[-0, +0, –]
int lua_isnil (lua_State *L, int index);
Returns 1 if the value at the given index is nil, and 0 otherwise.
lua_isnone
[-0, +0, –]
int lua_isnone (lua_State *L, int index);
Returns 1 if the given index is not valid, and 0 otherwise.
lua_isnoneornil
[-0, +0, –]
int lua_isnoneornil (lua_State *L, int index);
Returns 1 if the given index is not valid or if the value at this index is nil, and 0 otherwise.
lua_isnumber
[-0, +0, –]
int lua_isnumber (lua_State *L, int index);
Returns 1 if the value at the given index is a number or a string convertible to a number, and 0 otherwise.
lua_isstring
[-0, +0, –]
int lua_isstring (lua_State *L, int index);
Returns 1 if the value at the given index is a string or a number (which is always convertible to a string), and 0 otherwise.
lua_istable
[-0, +0, –]
int lua_istable (lua_State *L, int index);
Returns 1 if the value at the given index is a table, and 0 otherwise.
lua_isthread
[-0, +0, –]
int lua_isthread (lua_State *L, int index);
Returns 1 if the value at the given index is a thread, and 0 otherwise.
lua_isuserdata
[-0, +0, –]
int lua_isuserdata (lua_State *L, int index);
Returns 1 if the value at the given index is a userdata (either full or light), and 0 otherwise.
lua_len
[-0, +1, e]
void lua_len (lua_State *L, int index);
Returns the "length" of the value at the given index; it is equivalent to the '#' operator in Lua (see §3.4.6). The result is pushed on the stack.
lua_load
[-0, +1, –]
int lua_load (lua_State *L,
lua_Reader reader,
void *data,
const char *source,
const char *mode);
Loads a Lua chunk (without running it). If there are no errors, lua_load pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message.
The return values of lua_load are:
LUA_OK: no errors;LUA_ERRSYNTAX: syntax error during precompilation;LUA_ERRMEM: memory allocation error;LUA_ERRGCMM: error while running a__gcmetamethod. (This error has no relation with the chunk being loaded. It is generated by the garbage collector.)
The lua_load function uses a user-supplied reader function to read the chunk (see lua_Reader). The data argument is an opaque value passed to the reader function.
The source argument gives a name to the chunk, which is used for error messages and in debug information (see §4.9).
lua_load automatically detects whether the chunk is text or binary and loads it accordingly (see program luac). The string mode works as in function load, with the addition that a NULLvalue is equivalent to the string "bt".
lua_load uses the stack internally, so the reader function should always leave the stack unmodified when returning.
If the resulting function has one upvalue, this upvalue is set to the value of the global environment stored at index LUA_RIDX_GLOBALS in the registry (see §4.5). When loading main chunks, this upvalue will be the _ENV variable (see §2.2).
lua_newstate
[-0, +0, –]
lua_State *lua_newstate (lua_Alloc f, void *ud);
Creates a new thread running in a new, independent state. Returns NULL if cannot create the thread or the state (due to lack of memory). The argument f is the allocator function; Lua does all memory allocation for this state through this function. The second argument, ud, is an opaque pointer that Lua passes to the allocator in every call.
lua_newtable
[-0, +1, e]
void lua_newtable (lua_State *L);
Creates a new empty table and pushes it onto the stack. It is equivalent to lua_createtable(L, 0, 0).
lua_newthread
[-0, +1, e]
lua_State *lua_newthread (lua_State *L);
Creates a new thread, pushes it on the stack, and returns a pointer to a lua_State that represents this new thread. The new thread returned by this function shares with the original thread its global environment, but has an independent execution stack.
There is no explicit function to close or to destroy a thread. Threads are subject to garbage collection, like any Lua object.
lua_newuserdata
[-0, +1, e]
void *lua_newuserdata (lua_State *L, size_t size);
This function allocates a new block of memory with the given size, pushes onto the stack a new full userdata with the block address, and returns this address. The host program can freely use this memory.
lua_next
[-1, +(2|0), e]
int lua_next (lua_State *L, int index);
Pops a key from the stack, and pushes a key–value pair from the table at the given index (the "next" pair after the given key). If there are no more elements in the table, then lua_next returns 0 (and pushes nothing).
A typical traversal looks like this:
/* 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);
}
While traversing a table, do not call lua_tolstring directly on a key, unless you know that the key is actually a string. Recall that lua_tolstring may change the value at the given index; this confuses the next call to lua_next.
See function next for the caveats of modifying the table during its traversal.
lua_Number
typedef double lua_Number;
The type of numbers in Lua. By default, it is double, but that can be changed in luaconf.h. Through this configuration file you can change Lua to operate with another type for numbers (e.g., float or long).
lua_pcall
[-(nargs + 1), +(nresults|1), –]
int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);
Calls a function in protected mode.
Both nargs and nresults have the same meaning as in lua_call. If there are no errors during the call, lua_pcall behaves exactly like lua_call. However, if there is any error,lua_pcall catches it, pushes a single value on the stack (the error message), and returns an error code. Like lua_call, lua_pcall always removes the function and its arguments from the stack.
If msgh is 0, then the error message returned on the stack is exactly the original error message. Otherwise, msgh is the stack index of a message handler. (In the current implementation, this index cannot be a pseudo-index.) In case of runtime errors, this function will be called with the error message and its return value will be the message returned on the stack by lua_pcall.
Typically, the message handler is used to add more debug information to the error message, such as a stack traceback. Such information cannot be gathered after the return of lua_pcall, since by then the stack has unwound.
The lua_pcall function returns one of the following codes (defined in lua.h):
LUA_OK(0): success.LUA_ERRRUN: a runtime error.LUA_ERRMEM: memory allocation error. For such errors, Lua does not call the message handler.LUA_ERRERR: error while running the message handler.LUA_ERRGCMM: error while running a__gcmetamethod. (This error typically has no relation with the function being called. It is generated by the garbage collector.)
lua_pcallk
[-(nargs + 1), +(nresults|1), –]
int lua_pcallk (lua_State *L,
int nargs,
int nresults,
int errfunc,
int ctx,
lua_CFunction k);
This function behaves exactly like lua_pcall, but allows the called function to yield (see §4.7).
lua_pop
[-n, +0, –]
void lua_pop (lua_State *L, int n);
Pops n elements from the stack.
lua_pushboolean
[-0, +1, –]
void lua_pushboolean (lua_State *L, int b);
Pushes a boolean value with value b onto the stack.
lua_pushcclosure
[-n, +1, e]
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
Pushes a new C closure onto the stack.
When a C function is created, it is possible to associate some values with it, thus creating a C closure (see §4.4); these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first). Then lua_pushcclosure is called to create and push the C function onto the stack, with the argument n telling how many values should be associated with the function. lua_pushcclosure also pops these values from the stack.
The maximum value for n is 255.
When n is zero, this function creates a light C function, which is just a pointer to the C function. In that case, it never throws a memory error.
lua_pushcfunction
[-0, +1, –]
void lua_pushcfunction (lua_State *L, lua_CFunction f);
Pushes a C function onto the stack. This function receives a pointer to a C function and pushes onto the stack a Lua value of type function that, when called, invokes the corresponding C function.
Any function to be registered in Lua must follow the correct protocol to receive its parameters and return its results (see lua_CFunction).
lua_pushcfunction is defined as a macro:
#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)
Note that f is used twice.
lua_pushfstring
[-0, +1, e]
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
Pushes onto the stack a formatted string and returns a pointer to this string. It is similar to the ANSI C function sprintf, but has some important differences:
- You do not have to allocate space for the result: the result is a Lua string and Lua takes care of memory allocation (and deallocation, through garbage collection).
- The conversion specifiers are quite restricted. There are no flags, widths, or precisions. The conversion specifiers can only be '
%%' (inserts a '%' in the string), '%s' (inserts a zero-terminated string, with no size restrictions), '%f' (inserts alua_Number), '%p' (inserts a pointer as a hexadecimal numeral), '%d' (inserts anint), and '%c' (inserts anintas a byte).
lua_pushglobaltable
[-0, +1, –]
void lua_pushglobaltable (lua_State *L);
Pushes the global environment onto the stack.
lua_pushinteger
[-0, +1, –]
void lua_pushinteger (lua_State *L, lua_Integer n);
Pushes a number with value n onto the stack.
lua_pushlightuserdata
[-0, +1, –]
void lua_pushlightuserdata (lua_State *L, void *p);
Pushes a light userdata onto the stack.
Userdata represent C values in Lua. A light userdata represents a pointer, a void*. It is a value (like a number): you do not create it, it has no individual metatable, and it is not collected (as it was never created). A light userdata is equal to "any" light userdata with the same C address.
lua_pushliteral
[-0, +1, e]
const char *lua_pushliteral (lua_State *L, const char *s);
This macro is equivalent to lua_pushlstring, but can be used only when s is a literal string. It automatically provides the string length.
lua_pushlstring
[-0, +1, e]
const char *lua_pushlstring (lua_State *L, const char *s, size_t len);
Pushes the string pointed to by s with size len onto the stack. Lua makes (or reuses) an internal copy of the given string, so the memory at s can be freed or reused immediately after the function returns. The string can contain any binary data, including embedded zeros.
Returns a pointer to the internal copy of the string.
lua_pushnil
[-0, +1, –]
void lua_pushnil (lua_State *L);
Pushes a nil value onto the stack.
lua_pushnumber
[-0, +1, –]
void lua_pushnumber (lua_State *L, lua_Number n);
Pushes a number with value n onto the stack.
lua_pushstring
[-0, +1, e]
const char *lua_pushstring (lua_State *L, const char *s);
Pushes the zero-terminated string pointed to by s onto the stack. Lua makes (or reuses) an internal copy of the given string, so the memory at s can be freed or reused immediately after the function returns.
Returns a pointer to the internal copy of the string.
If s is NULL, pushes nil and returns NULL.
lua_pushthread
[-0, +1, –]
int lua_pushthread (lua_State *L);
Pushes the thread represented by L onto the stack. Returns 1 if this thread is the main thread of its state.
lua_pushunsigned
[-0, +1, –]
void lua_pushunsigned (lua_State *L, lua_Unsigned n);
Pushes a number with value n onto the stack.
lua_pushvalue
[-0, +1, –]
void lua_pushvalue (lua_State *L, int index);
Pushes a copy of the element at the given index onto the stack.
lua_pushvfstring
[-0, +1, e]
const char *lua_pushvfstring (lua_State *L,
const char *fmt,
va_list argp);
Equivalent to lua_pushfstring, except that it receives a va_list instead of a variable number of arguments.
lua_rawequal
[-0, +0, –]
int lua_rawequal (lua_State *L, int index1, int index2);
Returns 1 if the two values in indices index1 and index2 are primitively equal (that is, without calling metamethods). Otherwise returns 0. Also returns 0 if any of the indices are non valid.
lua_rawget
[-1, +1, –]
void lua_rawget (lua_State *L, int index);
Similar to lua_gettable, but does a raw access (i.e., without metamethods).
lua_rawgeti
[-0, +1, –]
void lua_rawgeti (lua_State *L, int index, int n);
Pushes onto the stack the value t[n], where t is the table at the given index. The access is raw; that is, it does not invoke metamethods.
lua_rawgetp
[-0, +1, –]
void lua_rawgetp (lua_State *L, int index, const void *p);
Pushes onto the stack the value t[k], where t is the table at the given index and k is the pointer p represented as a light userdata. The access is raw; that is, it does not invoke metamethods.
lua_rawlen
[-0, +0, –]
size_t lua_rawlen (lua_State *L, int index);
Returns the raw "length" of the value at the given index: for strings, this is the string length; for tables, this is the result of the length operator ('#') with no metamethods; for userdata, this is the size of the block of memory allocated for the userdata; for other values, it is 0.
lua_rawset
[-2, +0, e]
void lua_rawset (lua_State *L, int index);
Similar to lua_settable, but does a raw assignment (i.e., without metamethods).
lua_rawseti
[-1, +0, e]
void lua_rawseti (lua_State *L, int index, int n);
Does the equivalent of t[n] = v, where t is the table at the given index and v is the value at the top of the stack.
This function pops the value from the stack. The assignment is raw; that is, it does not invoke metamethods.
lua_rawsetp
[-1, +0, e]
void lua_rawsetp (lua_State *L, int index, const void *p);
Does the equivalent of t[k] = v, where t is the table at the given index, k is the pointer p represented as a light userdata, and v is the value at the top of the stack.
This function pops the value from the stack. The assignment is raw; that is, it does not invoke metamethods.
lua_Reader
typedef const char * (*lua_Reader) (lua_State *L,
void *data,
size_t *size);
The reader function used by lua_load. Every time it needs another piece of the chunk, lua_load calls the reader, passing along its data parameter. The reader must return a pointer to a block of memory with a new piece of the chunk and set size to the block size. The block must exist until the reader function is called again. To signal the end of the chunk, the reader must return NULL or set size to zero. The reader function may return pieces of any size greater than zero.
lua_register
[-0, +0, e]
void lua_register (lua_State *L, const char *name, lua_CFunction f);
Sets the C function f as the new value of global name. It is defined as a macro:
#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);
Removes the element at the given valid index, shifting down the elements above this index to fill the gap. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.
lua_replace
[-1, +0, –]
void lua_replace (lua_State *L, int index);
Moves the top element into the given valid index without shifting any element (therefore replacing the value at the given index), and then pops the top element.
lua_resume
[-?, +?, –]
int lua_resume (lua_State *L, lua_State *from, int nargs);
Starts and resumes a coroutine in a given thread.
To start a coroutine, you push onto the thread stack the main function plus any arguments; then you call lua_resume, with nargs being the number of arguments. This call returns when the coroutine suspends or finishes its execution. When it returns, the stack contains all values passed to lua_yield, or all values returned by the body function. lua_resume returnsLUA_YIELD if the coroutine yields, LUA_OK if the coroutine finishes its execution without errors, or an error code in case of errors (see lua_pcall).
In case of errors, the stack is not unwound, so you can use the debug API over it. The error message is on the top of the stack.
To resume a coroutine, you remove any results from the last lua_yield, put on its stack only the values to be passed as results from yield, and then call lua_resume.
The parameter from represents the coroutine that is resuming L. If there is no such coroutine, this parameter can be NULL.
lua_setallocf
[-0, +0, –]
void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
Changes the allocator function of a given state to f with user data ud.
lua_setfield
[-1, +0, e]
void lua_setfield (lua_State *L, int index, const char *k);
Does the equivalent to t[k] = v, where t is the value at the given index and v is the value at the top of the stack.
This function pops the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.4).
lua_setglobal
[-1, +0, e]
void lua_setglobal (lua_State *L, const char *name);
Pops a value from the stack and sets it as the new value of global name.
lua_setmetatable
[-1, +0, –]
void lua_setmetatable (lua_State *L, int index);
Pops a table from the stack and sets it as the new metatable for the value at the given index.
lua_settable
[-2, +0, e]
void lua_settable (lua_State *L, int index);
Does the equivalent to t[k] = v, where t is the value at the given index, v is the value at the top of the stack, and k is the value just below the top.
This function pops both the key and the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.4).
lua_settop
[-?, +?, –]
void lua_settop (lua_State *L, int index);
Accepts any index, or 0, and sets the stack top to this index. If the new top is larger than the old one, then the new elements are filled with nil. If index is 0, then all stack elements are removed.
lua_setuservalue
[-1, +0, –]
void lua_setuservalue (lua_State *L, int index);
Pops a table or nil from the stack and sets it as the new value associated to the userdata at the given index.
lua_State
typedef struct lua_State lua_State;
An opaque structure that points to a thread and indirectly (through the thread) to the whole state of a Lua interpreter. The Lua library is fully reentrant: it has no global variables. All information about a state is accessible through this structure.
A pointer to this structure must be passed as the first argument to every function in the library, except to lua_newstate, which creates a Lua state from scratch.
lua_status
[-0, +0, –]
int lua_status (lua_State *L);
Returns the status of the thread L.
The status can be 0 (LUA_OK) for a normal thread, an error code if the thread finished the execution of a lua_resume with an error, or LUA_YIELD if the thread is suspended.
You can only call functions in threads with status LUA_OK. You can resume threads with status LUA_OK (to start a new coroutine) or LUA_YIELD (to resume a coroutine).
lua_toboolean
[-0, +0, –]
int lua_toboolean (lua_State *L, int index);
Converts the Lua value at the given index to a C boolean value (0 or 1). Like all tests in Lua, lua_toboolean returns true for any Lua value different from false and nil; otherwise it returns false. (If you want to accept only actual boolean values, use lua_isboolean to test the value's type.)
lua_tocfunction
[-0, +0, –]
lua_CFunction lua_tocfunction (lua_State *L, int index);
Converts a value at the given index to a C function. That value must be a C function; otherwise, returns NULL.
lua_tointeger
[-0, +0, –]
lua_Integer lua_tointeger (lua_State *L, int index);
Equivalent to lua_tointegerx with isnum equal to NULL.
lua_tointegerx
[-0, +0, –]
lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);
Converts the Lua value at the given index to the signed integral type lua_Integer. The Lua value must be a number or a string convertible to a number (see §3.4.2); otherwise,lua_tointegerx returns 0.
If the number is not an integer, it is truncated in some non-specified way.
If isnum is not NULL, its referent is assigned a boolean value that indicates whether the operation succeeded.
lua_tolstring
[-0, +0, e]
const char *lua_tolstring (lua_State *L, int index, size_t *len);
Converts the Lua value at the given index to a C string. If len is not NULL, it also sets *len with the string length. The Lua value must be a string or a number; otherwise, the function returnsNULL. If the value is a number, then lua_tolstring also changes the actual value in the stack to a string. (This change confuses lua_next when lua_tolstring is applied to keys during a table traversal.)
lua_tolstring returns a fully aligned pointer to a string inside the Lua state. This string always has a zero ('\0') after its last character (as in C), but can contain other zeros in its body. Because Lua has garbage collection, there is no guarantee that the pointer returned by lua_tolstring will be valid after the corresponding value is removed from the stack.
lua_tonumber
[-0, +0, –]
lua_Number lua_tonumber (lua_State *L, int index);
Equivalent to lua_tonumberx with isnum equal to NULL.
lua_tonumberx
[-0, +0, –]
lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);
Converts the Lua value at the given index to the C type lua_Number (see lua_Number). The Lua value must be a number or a string convertible to a number (see §3.4.2); otherwise,lua_tonumberx returns 0.
If isnum is not NULL, its referent is assigned a boolean value that indicates whether the operation succeeded.
lua_topointer
[-0, +0, –]
const void *lua_topointer (lua_State *L, int index);
Converts the value at the given index to a generic C pointer (void*). The value can be a userdata, a table, a thread, or a function; otherwise, lua_topointer returns NULL. Different objects will give different pointers. There is no way to convert the pointer back to its original value.
Typically this function is used only for debug information.
lua_tostring
[-0, +0, e]
const char *lua_tostring (lua_State *L, int index);
Equivalent to lua_tolstring with len equal to NULL.
lua_tothread
[-0, +0, –]
lua_State *lua_tothread (lua_State *L, int index);
Converts the value at the given index to a Lua thread (represented as lua_State*). This value must be a thread; otherwise, the function returns NULL.
lua_tounsigned
[-0, +0, –]
lua_Unsigned lua_tounsigned (lua_State *L, int index);
Equivalent to lua_tounsignedx with isnum equal to NULL.
lua_tounsignedx
[-0, +0, –]
lua_Unsigned lua_tounsignedx (lua_State *L, int index, int *isnum);
Converts the Lua value at the given index to the unsigned integral type lua_Unsigned. The Lua value must be a number or a string convertible to a number (see §3.4.2); otherwise,lua_tounsignedx returns 0.
If the number is not an integer, it is truncated in some non-specified way. If the number is outside the range of representable values, it is normalized to the remainder of its division by one more than the maximum representable value.
If isnum is not NULL, its referent is assigned a boolean value that indicates whether the operation succeeded.
lua_touserdata
[-0, +0, –]
void *lua_touserdata (lua_State *L, int index);
If the value at the given index is a full userdata, returns its block address. If the value is a light userdata, returns its pointer. Otherwise, returns NULL.
lua_type
[-0, +0, –]
int lua_type (lua_State *L, int index);
Returns the type of the value in the given valid index, or LUA_TNONE for a non-valid (but acceptable) index. The types returned by lua_type are coded by the following constants defined inlua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD, and LUA_TLIGHTUSERDATA.
lua_typename
[-0, +0, –]
const char *lua_typename (lua_State *L, int tp);
Returns the name of the type encoded by the value tp, which must be one the values returned by lua_type.
lua_Unsigned
typedef unsigned long lua_Unsigned;
The type used by the Lua API to represent unsigned integral values. It must have at least 32 bits.
By default it is an unsigned int or an unsigned long, whichever can hold 32-bit values.
lua_upvalueindex
[-0, +0, –]
int lua_upvalueindex (int i);
Returns the pseudo-index that represents the i-th upvalue of the running function (see §4.4).
lua_version
[-0, +0, v]
const lua_Number *lua_version (lua_State *L);
Returns the address of the version number stored in the Lua core. When called with a valid lua_State, returns the address of the version used to create that state. When called with NULL, returns the address of the version running the call.
lua_Writer
typedef int (*lua_Writer) (lua_State *L,
const void* p,
size_t sz,
void* ud);
The type of the writer function used by lua_dump. Every time it produces another piece of chunk, lua_dump calls the writer, passing along the buffer to be written (p), its size (sz), and thedata parameter supplied to lua_dump.
The writer returns an error code: 0 means no errors; any other value means an error and stops lua_dump from calling the writer again.
lua_xmove
[-?, +?, –]
void lua_xmove (lua_State *from, lua_State *to, int n);
Exchange values between different threads of the same state.
This function pops n values from the stack from, and pushes them onto the stack to.
lua_yield
[-?, +?, –]
int lua_yield (lua_State *L, int nresults);
This function is equivalent to lua_yieldk, but it has no continuation (see §4.7). Therefore, when the thread resumes, it returns to the function that called the function calling lua_yield.
lua_yieldk
[-?, +?, –]
int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);
Yields a coroutine.
This function should only be called as the return expression of a C function, as follows:
return lua_yieldk (L, n, i, k);
When a C function calls lua_yieldk in that way, the running coroutine suspends its execution, and the call to lua_resume that started this coroutine returns. The parameter nresults is the number of values from the stack that are passed as results to lua_resume.
When the coroutine is resumed again, Lua calls the given continuation function k to continue the execution of the C function that yielded (see §4.7). This continuation function receives the same stack from the previous function, with the results removed and replaced by the arguments passed to lua_resume. Moreover, the continuation function may access the value ctx by callinglua_getctx.
4.9 – The Debug Interface
Lua has no built-in debugging facilities. Instead, it offers a special interface by means of functions and hooks. This interface allows the construction of different kinds of debuggers, profilers, and other tools that need "inside information" from the interpreter.
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 linedefined; /* (S) */
int lastlinedefined; /* (S) */
unsigned char nups; /* (u) number of upvalues */
unsigned char nparams; /* (u) number of parameters */
char isvararg; /* (u) */
char istailcall; /* (t) */
char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
other fields
} lua_Debug;
A structure used to carry different pieces of information about a function or an activation record. lua_getstack fills only the private part of this structure, for later use. To fill the other fields oflua_Debug with useful information, call lua_getinfo.
The fields of lua_Debug have the following meaning:
source: the source of the chunk that created the function. Ifsourcestarts with a '@', it means that the function was defined in a file where the file name follows the '@'. Ifsourcestarts with a '=', the remainder of its contents describe the source in a user-dependent manner. Otherwise, the function was defined in a string wheresourceis that string.short_src: a "printable" version ofsource, to be used in error messages.linedefined: the line number where the definition of the function starts.lastlinedefined: the line number where the definition of the function ends.what: the string"Lua"if the function is a Lua function,"C"if it is a C function,"main"if it is the main part of a chunk.currentline: the current line where the given function is executing. When no line information is available,currentlineis set to -1.name: a reasonable name for the given function. Because functions in Lua are first-class values, they do not have a fixed name: some functions can be the value of multiple global variables, while others can be stored only in a table field. Thelua_getinfofunction checks how the function was called to find a suitable name. If it cannot find a name, thennameis set toNULL.namewhat: explains thenamefield. The value ofnamewhatcan be"global","local","method","field","upvalue", or""(the empty string), according to how the function was called. (Lua uses the empty string when no other option seems to apply.)istailcall: true if this function invocation was called by a tail call. In this case, the caller of this level is not in the stack.nups: the number of upvalues of the function.nparams: the number of fixed parameters of the function (always 0 for C functions).isvararg: true if the function is a vararg function (always true for C functions).
lua_gethook
[-0, +0, –]
lua_Hook lua_gethook (lua_State *L);
Returns the current hook function.
lua_gethookcount
[-0, +0, –]
int lua_gethookcount (lua_State *L);
Returns the current hook count.
lua_gethookmask
[-0, +0, –]
int lua_gethookmask (lua_State *L);
Returns the current hook mask.
lua_getinfo
[-(0|1), +(0|1|2), e]
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
Gets information about a specific function or function invocation.
To get information about a function invocation, the parameter ar must be a valid activation record that was filled by a previous call to lua_getstack or given as argument to a hook (seelua_Hook).
To get information about a function you push it onto the stack and start the what string with the character '>'. (In that case, lua_getinfo pops the function from the top of the stack.) For instance, to know in which line a function f was defined, you can write the following code:
lua_Debug ar;
lua_getglobal(L, "f"); /* get global 'f' */
lua_getinfo(L, ">S", &ar);
printf("%d\n", ar.linedefined);
Each character in the string what selects some fields of the structure ar to be filled or a value to be pushed on the stack:
- '
n': fills in the fieldnameandnamewhat; - '
S': fills in the fieldssource,short_src,linedefined,lastlinedefined, andwhat; - '
l': fills in the fieldcurrentline; - '
t': fills in the fieldistailcall; - '
u': fills in the fieldsnups,nparams, andisvararg; - '
f': pushes onto the stack the function that is running at the given level; - '
L': pushes onto the stack a table whose indices are the numbers of the lines that are valid on the function. (A valid line is a line with some associated code, that is, a line where you can put a break point. Non-valid lines include empty lines and comments.)
This function returns 0 on error (for instance, an invalid option in what).
lua_getlocal
[-0, +(0|1), –]
const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);
Gets information about a local variable of a given activation record or a given function.
In the first case, the parameter ar must be a valid activation record that was filled by a previous call to lua_getstack or given as argument to a hook (see lua_Hook). The index n selects which local variable to inspect; see debug.getlocal for details about variable indices and names.
lua_getlocal pushes the variable's value onto the stack and returns its name.
In the second case, ar should be NULL and the function to be inspected must be at the top of the stack. In this case, only parameters of Lua functions are visible (as there is no information about what variables are active) and no values are pushed onto the stack.
Returns NULL (and pushes nothing) when the index is greater than the number of active local variables.
lua_getstack
[-0, +0, –]
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
Gets information about the interpreter runtime stack.
This function fills parts of a lua_Debug structure with an identification of the activation record of the function executing at a given level. Level 0 is the current running function, whereas leveln+1 is the function that has called level n (except for tail calls, which do not count on the stack). When there are no errors, lua_getstack returns 1; when called with a level greater than the stack depth, it returns 0.
lua_getupvalue
[-0, +(0|1), –]
const char *lua_getupvalue (lua_State *L, int funcindex, int n);
Gets information about a closure's upvalue. (For Lua functions, upvalues are the external local variables that the function uses, and that are consequently included in its closure.)lua_getupvalue gets the index n of an upvalue, pushes the upvalue's value onto the stack, and returns its name. funcindex points to the closure in the stack. (Upvalues have no particular order, as they are active through the whole function. So, they are numbered in an arbitrary order.)
Returns NULL (and pushes nothing) when the index is greater than the number of upvalues. For C functions, this function uses the empty string "" as a name for all upvalues.
lua_Hook
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
Type for debugging hook functions.
Whenever a hook is called, its ar argument has its field event set to the specific event that triggered the hook. Lua identifies these events with the following constants: LUA_HOOKCALL,LUA_HOOKRET, LUA_HOOKTAILCALL, LUA_HOOKLINE, and LUA_HOOKCOUNT. Moreover, for line events, the field currentline is also set. To get the value of any other field in ar, the hook must call lua_getinfo.
For call events, event can be LUA_HOOKCALL, the normal value, or LUA_HOOKTAILCALL, for a tail call; in this case, there will be no corresponding return event.
While Lua is running a hook, it disables other calls to hooks. Therefore, if a hook calls back Lua to execute a function or a chunk, this execution occurs without any calls to hooks.
Hook functions cannot have continuations, that is, they cannot call lua_yieldk, lua_pcallk, or lua_callk with a non-null k.
Hook functions can yield under the following conditions: Only count and line events can yield and they cannot yield any value; to yield a hook function must finish its execution callinglua_yield with nresults equal to zero.
lua_sethook
[-0, +0, –]
int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
Sets the debugging hook function.
Argument f is the hook function. mask specifies on which events the hook will be called: it is formed by a bitwise or of the constants LUA_MASKCALL, LUA_MASKRET, LUA_MASKLINE, andLUA_MASKCOUNT. The count argument is only meaningful when the mask includes LUA_MASKCOUNT. For each event, the hook is called as explained below:
- The call hook: is called when the interpreter calls a function. The hook is called just after Lua enters the new function, before the function gets its arguments.
- The return hook: is called when the interpreter returns from a function. The hook is called just before Lua leaves the function. There is no standard way to access the values to be returned by the function.
- The line hook: is called when the interpreter is about to start the execution of a new line of code, or when it jumps back in the code (even to the same line). (This event only happens while Lua is executing a Lua function.)
- The count hook: is called after the interpreter executes every
countinstructions. (This event only happens while Lua is executing a Lua function.)
A hook is disabled by setting mask to zero.
lua_setlocal
[-(0|1), +0, –]
const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
Sets the value of a local variable of a given activation record. Parameters ar and n are as in lua_getlocal (see lua_getlocal). lua_setlocal assigns the value at the top of the stack to the variable and returns its name. It also pops the value from the stack.
Returns NULL (and pops nothing) when the index is greater than the number of active local variables.
lua_setupvalue
[-(0|1), +0, –]
const char *lua_setupvalue (lua_State *L, int funcindex, int n);
Sets the value of a closure's upvalue. It assigns the value at the top of the stack to the upvalue and returns its name. It also pops the value from the stack. Parameters funcindex and n are as in the lua_getupvalue (see lua_getupvalue).
Returns NULL (and pops nothing) when the index is greater than the number of upvalues.
lua_upvalueid
[-0, +0, –]
void *lua_upvalueid (lua_State *L, int funcindex, int n);
Returns an unique identifier for the upvalue numbered n from the closure at index funcindex. Parameters funcindex and n are as in the lua_getupvalue (see lua_getupvalue) (butn cannot be greater than the number of upvalues).
These unique identifiers allow a program to check whether different closures share upvalues. Lua closures that share an upvalue (that is, that access a same external local variable) will return identical ids for those upvalue indices.
lua_upvaluejoin
[-0, +0, –]
void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
int funcindex2, int n2);
Make the n1-th upvalue of the Lua closure at index funcindex1 refer to the n2-th upvalue of the Lua closure at index funcindex2.
5 – The Auxiliary Library
The auxiliary library provides several convenient functions to interface C with Lua. While the basic API provides the primitive functions for all interactions between C and Lua, the auxiliary library provides higher-level functions for some common tasks.
All functions and types from the auxiliary library are defined in header file lauxlib.h and have a prefix luaL_.
All functions in the auxiliary library are built on top of the basic API, and so they provide nothing that cannot be done with that API. Nevertheless, the use of the auxiliary library ensures more consistency to your code.
Several functions in the auxiliary library use internally some extra stack slots. When a function in the auxiliary library uses less than five slots, it does not check the stack size; it simply assumes that there are enough slots.
Several functions in the auxiliary library are used to check C function arguments. Because the error message is formatted for arguments (e.g., "bad argument #1"), you should not use these functions for other stack values.
Functions called luaL_check* always throw an error if the check is not satisfied.
5.1 – Functions and Types
Here we list all functions and types from the auxiliary library in alphabetical order.
luaL_addchar
[-?, +?, e]
void luaL_addchar (luaL_Buffer *B, char c);
Adds the byte c to the buffer B (see luaL_Buffer).
luaL_addlstring
[-?, +?, e]
void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
Adds the string pointed to by s with length l to the buffer B (see luaL_Buffer). The string can contain embedded zeros.
luaL_addsize
[-?, +?, e]
void luaL_addsize (luaL_Buffer *B, size_t n);
Adds to the buffer B (see luaL_Buffer) a string of length n previously copied to the buffer area (see luaL_prepbuffer).
luaL_addstring
[-?, +?, e]
void luaL_addstring (luaL_Buffer *B, const char *s);
Adds the zero-terminated string pointed to by s to the buffer B (see luaL_Buffer). The string cannot contain embedded zeros.
luaL_addvalue
[-1, +?, e]
void luaL_addvalue (luaL_Buffer *B);
Adds the value at the top of the stack to the buffer B (see luaL_Buffer). Pops the value.
This is the only function on string buffers that can (and must) be called with an extra element on the stack, which is the value to be added to the buffer.
luaL_argcheck
[-0, +0, v]
void luaL_argcheck (lua_State *L,
int cond,
int arg,
const char *extramsg);
Checks whether cond is true. If not, raises an error with a standard message.
luaL_argerror
[-0, +0, v]
int luaL_argerror (lua_State *L, int arg, const char *extramsg);
Raises an error with a standard message that includes extramsg as a comment.
This function never returns, but it is an idiom to use it in C functions as return luaL_argerror(args).
luaL_Buffer
typedef struct luaL_Buffer luaL_Buffer;
Type for a string buffer.
A string buffer allows C code to build Lua strings piecemeal. Its pattern of use is as follows:
- First declare a variable
bof typeluaL_Buffer. - Then initialize it with a call
luaL_buffinit(L, &b). - Then add string pieces to the buffer calling any of the
luaL_add*functions. - Finish by calling
luaL_pushresult(&b). This call leaves the final string on the top of the stack.
If you know beforehand the total size of the resulting string, you can use the buffer like this:
- First declare a variable
bof typeluaL_Buffer. - Then initialize it and preallocate a space of size
szwith a callluaL_buffinitsize(L, &b, sz). - Then copy the string into that space.
- Finish by calling
luaL_pushresultsize(&b, sz), whereszis the total size of the resulting string copied into that space.
During its normal operation, a string buffer uses a variable number of stack slots. So, while using a buffer, you cannot assume that you know where the top of the stack is. You can use the stack between successive calls to buffer operations as long as that use is balanced; that is, when you call a buffer operation, the stack is at the same level it was immediately after the previous buffer operation. (The only exception to this rule is luaL_addvalue.) After calling luaL_pushresult the stack is back to its level when the buffer was initialized, plus the final string on its top.
luaL_buffinit
[-0, +0, –]
void luaL_buffinit (lua_State *L, luaL_Buffer *B);
Initializes a buffer B. This function does not allocate any space; the buffer must be declared as a variable (see luaL_Buffer).
luaL_buffinitsize
[-?, +?, e]
char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);
Equivalent to the sequence luaL_buffinit, luaL_prepbuffsize.
luaL_callmeta
[-0, +(0|1), e]
int luaL_callmeta (lua_State *L, int obj, const char *e);
Calls a metamethod.
If the object at index obj has a metatable and this metatable has a field e, this function calls this field passing the object as its only argument. In this case this function returns true and pushes onto the stack the value returned by the call. If there is no metatable or no metamethod, this function returns false (without pushing any value on the stack).
luaL_checkany
[-0, +0, v]
void luaL_checkany (lua_State *L, int arg);
Checks whether the function has an argument of any type (including nil) at position arg.
luaL_checkint
[-0, +0, v]
int luaL_checkint (lua_State *L, int arg);
Checks whether the function argument arg is a number and returns this number cast to an int.
luaL_checkinteger
[-0, +0, v]
lua_Integer luaL_checkinteger (lua_State *L, int arg);
Checks whether the function argument arg is a number and returns this number cast to a lua_Integer.
luaL_checklong
[-0, +0, v]
long luaL_checklong (lua_State *L, int arg);
Checks whether the function argument arg is a number and returns this number cast to a long.
luaL_checklstring
[-0, +0, v]
const char *luaL_checklstring (lua_State *L, int arg, size_t *l);
Checks whether the function argument arg is a string and returns this string; if l is not NULL fills *l with the string's length.
This function uses lua_tolstring to get its result, so all conversions and caveats of that function apply here.
luaL_checknumber
[-0, +0, v]
lua_Number luaL_checknumber (lua_State *L, int arg);
Checks whether the function argument arg is a number and returns this number.
luaL_checkoption
[-0, +0, v]
int luaL_checkoption (lua_State *L,
int arg,
const char *def,
const char *const lst[]);
Checks whether the function argument arg is a string and searches for this string in the array lst (which must be NULL-terminated). Returns the index in the array where the string was found. Raises an error if the argument is not a string or if the string cannot be found.
If def is not NULL, the function uses def as a default value when there is no argument arg or when this argument is nil.
This is a useful function for mapping strings to C enums. (The usual convention in Lua libraries is to use strings instead of numbers to select options.)
luaL_checkstack
[-0, +0, v]
void luaL_checkstack (lua_State *L, int sz, const char *msg);
Grows the stack size to top + sz elements, raising an error if the stack cannot grow to that size. msg is an additional text to go into the error message (or NULL for no additional text).
luaL_checkstring
[-0, +0, v]
const char *luaL_checkstring (lua_State *L, int arg);
Checks whether the function argument arg is a string and returns this string.
This function uses lua_tolstring to get its result, so all conversions and caveats of that function apply here.
luaL_checktype
[-0, +0, v]
void luaL_checktype (lua_State *L, int arg, int t);
Checks whether the function argument arg has type t. See lua_type for the encoding of types for t.
luaL_checkudata
[-0, +0, v]
void *luaL_checkudata (lua_State *L, int arg, const char *tname);
Checks whether the function argument arg is a userdata of the type tname (see luaL_newmetatable) and returns the userdata address (see lua_touserdata).
luaL_checkunsigned
[-0, +0, v]
lua_Unsigned luaL_checkunsigned (lua_State *L, int arg);
Checks whether the function argument arg is a number and returns this number cast to a lua_Unsigned.
luaL_checkversion
[-0, +0, –]
void luaL_checkversion (lua_State *L);
Checks whether the core running the call, the core that created the Lua state, and the code making the call are all using the same version of Lua. Also checks whether the core running the call and the core that created the Lua state are using the same address space.
luaL_dofile
[-0, +?, e]
int luaL_dofile (lua_State *L, const char *filename);
Loads and runs the given file. It is defined as the following macro:
(luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
It returns false if there are no errors or true in case of errors.
luaL_dostring
[-0, +?, –]
int luaL_dostring (lua_State *L, const char *str);
Loads and runs the given string. It is defined as the following macro:
(luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
It returns false if there are no errors or true in case of errors.
luaL_error
[-0, +0, v]
int luaL_error (lua_State *L, const char *fmt, ...);
Raises an error. The error message format is given by fmt plus any extra arguments, following the same rules of lua_pushfstring. It also adds at the beginning of the message the file name and the line number where the error occurred, if this information is available.
This function never returns, but it is an idiom to use it in C functions as return luaL_error(args).
luaL_execresult
[-0, +3, e]
int luaL_execresult (lua_State *L, int stat);
This function produces the return values for process-related functions in the standard library (os.execute and io.close).
luaL_fileresult
[-0, +(1|3), e]
int luaL_fileresult (lua_State *L, int stat, const char *fname);
This function produces the return values for file-related functions in the standard library (io.open, os.rename, file:seek, etc.).
luaL_getmetafield
[-0, +(0|1), e]
int luaL_getmetafield (lua_State *L, int obj, const char *e);
Pushes onto the stack the field e from the metatable of the object at index obj. If the object does not have a metatable, or if the metatable does not have this field, returns false and pushes nothing.
luaL_getmetatable
[-0, +1, –]
void luaL_getmetatable (lua_State *L, const char *tname);
Pushes onto the stack the metatable associated with name tname in the registry (see luaL_newmetatable).
luaL_getsubtable
[-0, +1, e]
int luaL_getsubtable (lua_State *L, int idx, const char *fname);
Ensures that the value t[fname], where t is the value at index idx, is a table, and pushes that table onto the stack. Returns true if it finds a previous table there and false if it creates a new table.
luaL_gsub
[-0, +1, e]
const char *luaL_gsub (lua_State *L,
const char *s,
const char *p,
const char *r);
Creates a copy of string s by replacing any occurrence of the string p with the string r. Pushes the resulting string on the stack and returns it.
luaL_len
[-0, +0, e]
int luaL_len (lua_State *L, int index);
Returns the "length" of the value at the given index as a number; it is equivalent to the '#' operator in Lua (see §3.4.6). Raises an error if the result of the operation is not a number. (This case only can happen through metamethods.)
luaL_loadbuffer
[-0, +1, –]
int luaL_loadbuffer (lua_State *L,
const char *buff,
size_t sz,
const char *name);
Equivalent to luaL_loadbufferx with mode equal to NULL.
luaL_loadbufferx
[-0, +1, –]
int luaL_loadbufferx (lua_State *L,
const char *buff,
size_t sz,
const char *name,
const char *mode);
Loads a buffer as a Lua chunk. This function uses lua_load to load the chunk in the buffer pointed to by buff with size sz.
This function returns the same results as lua_load. name is the chunk name, used for debug information and error messages. The string mode works as in function lua_load.
luaL_loadfile
[-0, +1, e]
int luaL_loadfile (lua_State *L, const char *filename);
Equivalent to luaL_loadfilex with mode equal to NULL.
luaL_loadfilex
[-0, +1, e]
int luaL_loadfilex (lua_State *L, const char *filename,
const char *mode);
Loads a file as a Lua chunk. This function uses lua_load to load the chunk in the file named filename. If filename is NULL, then it loads from the standard input. The first line in the file is ignored if it starts with a #.
The string mode works as in function lua_load.
This function returns the same results as lua_load, but it has an extra error code LUA_ERRFILE if it cannot open/read the file or the file has a wrong mode.
As lua_load, this function only loads the chunk; it does not run it.
luaL_loadstring
[-0, +1, –]
int luaL_loadstring (lua_State *L, const char *s);
Loads a string as a Lua chunk. This function uses lua_load to load the chunk in the zero-terminated string s.
This function returns the same results as lua_load.
Also as lua_load, this function only loads the chunk; it does not run it.
luaL_newlib
[-0, +1, e]
void luaL_newlib (lua_State *L, const luaL_Reg *l);
Creates a new table and registers there the functions in list l. It is implemented as the following macro:
(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
luaL_newlibtable
[-0, +1, e]
void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);
Creates a new table with a size optimized to store all entries in the array l (but does not actually store them). It is intended to be used in conjunction with luaL_setfuncs (seeluaL_newlib).
It is implemented as a macro. The array l must be the actual array, not a pointer to it.
luaL_newmetatable
[-0, +1, e]
int luaL_newmetatable (lua_State *L, const char *tname);
If the registry already has the key tname, returns 0. Otherwise, creates a new table to be used as a metatable for userdata, adds it to the registry with key tname, and returns 1.
In both cases pushes onto the stack the final value associated with tname in the registry.
luaL_newstate
[-0, +0, –]
lua_State *luaL_newstate (void);
Creates a new Lua state. It calls lua_newstate with an allocator based on the standard C realloc function and then sets a panic function (see §4.6) that prints an error message to the standard error output in case of fatal errors.
Returns the new state, or NULL if there is a memory allocation error.
luaL_openlibs
[-0, +0, e]
void luaL_openlibs (lua_State *L);
Opens all standard Lua libraries into the given state.
luaL_optint
[-0, +0, v]
int luaL_optint (lua_State *L, int arg, int d);
If the function argument arg is a number, returns this number cast to an int. If this argument is absent or is nil, returns d. Otherwise, raises an error.
luaL_optinteger
[-0, +0, v]
lua_Integer luaL_optinteger (lua_State *L,
int arg,
lua_Integer d);
If the function argument arg is a number, returns this number cast to a lua_Integer. If this argument is absent or is nil, returns d. Otherwise, raises an error.
luaL_optlong
[-0, +0, v]
long luaL_optlong (lua_State *L, int arg, long d);
If the function argument arg is a number, returns this number cast to a long. If this argument is absent or is nil, returns d. Otherwise, raises an error.
luaL_optlstring
[-0, +0, v]
const char *luaL_optlstring (lua_State *L,
int arg,
const char *d,
size_t *l);
If the function argument arg is a string, returns this string. If this argument is absent or is nil, returns d. Otherwise, raises an error.
If l is not NULL, fills the position *l with the result's length.
luaL_optnumber
[-0, +0, v]
lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);
If the function argument arg is a number, returns this number. If this argument is absent or is nil, returns d. Otherwise, raises an error.
luaL_optstring
[-0, +0, v]
const char *luaL_optstring (lua_State *L,
int arg,
const char *d);
If the function argument arg is a string, returns this string. If this argument is absent or is nil, returns d. Otherwise, raises an error.
luaL_optunsigned
[-0, +0, v]
lua_Unsigned luaL_optunsigned (lua_State *L,
int arg,
lua_Unsigned u);
If the function argument arg is a number, returns this number cast to a lua_Unsigned. If this argument is absent or is nil, returns u. Otherwise, raises an error.
luaL_prepbuffer
[-?, +?, e]
char *luaL_prepbuffer (luaL_Buffer *B);
Equivalent to luaL_prepbuffsize with the predefined size LUAL_BUFFERSIZE.
luaL_prepbuffsize
[-?, +?, e]
char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);
Returns an address to a space of size sz where you can copy a string to be added to buffer B (see luaL_Buffer). After copying the string into this space you must call luaL_addsize with the size of the string to actually add it to the buffer.
luaL_pushresult
[-?, +1, e]
void luaL_pushresult (luaL_Buffer *B);
Finishes the use of buffer B leaving the final string on the top of the stack.
luaL_pushresultsize
[-?, +1, e]
void luaL_pushresultsize (luaL_Buffer *B, size_t sz);
Equivalent to the sequence luaL_addsize, luaL_pushresult.
luaL_ref
[-1, +0, e]
int luaL_ref (lua_State *L, int t);
Creates and returns a reference, in the table at index t, for the object at the top of the stack (and pops the object).
A reference is a unique integer key. As long as you do not manually add integer keys into table t, luaL_ref ensures the uniqueness of the key it returns. You can retrieve an object referred by reference r by calling lua_rawgeti(L, t, r). Function luaL_unref frees a reference and its associated object.
If the object at the top of the stack is nil, luaL_ref returns the constant LUA_REFNIL. The constant LUA_NOREF is guaranteed to be different from any reference returned by luaL_ref.
luaL_Reg
typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;
Type for arrays of functions to be registered by luaL_setfuncs. name is the function name and func is a pointer to the function. Any array of luaL_Reg must end with an sentinel entry in which both name and func are NULL.
luaL_requiref
[-0, +1, e]
void luaL_requiref (lua_State *L, const char *modname,
lua_CFunction openf, int glb);
Calls function openf with string modname as an argument and sets the call result in package.loaded[modname], as if that function has been called through require.
If glb is true, also stores the result into global modname.
Leaves a copy of that result on the stack.
luaL_setfuncs
[-nup, +0, e]
void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);
Registers all functions in the array l (see luaL_Reg) into the table on the top of the stack (below optional upvalues, see next).
When nup is not zero, all functions are created sharing nup upvalues, which must be previously pushed on the stack on top of the library table. These values are popped from the stack after the registration.
luaL_setmetatable
[-0, +0, –]
void luaL_setmetatable (lua_State *L, const char *tname);
Sets the metatable of the object at the top of the stack as the metatable associated with name tname in the registry (see luaL_newmetatable).
luaL_testudata
[-0, +0, e]
void *luaL_testudata (lua_State *L, int arg, const char *tname);
This function works like luaL_checkudata, except that, when the test fails, it returns NULL instead of throwing an error.
luaL_tolstring
[-0, +1, e]
const char *luaL_tolstring (lua_State *L, int idx, size_t *len);
Converts any Lua value at the given index to a C string in a reasonable format. The resulting string is pushed onto the stack and also returned by the function. If len is not NULL, the function also sets *len with the string length.
If the value has a metatable with a "__tostring" field, then luaL_tolstring calls the corresponding metamethod with the value as argument, and uses the result of the call as its result.
luaL_traceback
[-0, +1, e]
void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
int level);
Creates and pushes a traceback of the stack L1. If msg is not NULL it is appended at the beginning of the traceback. The level parameter tells at which level to start the traceback.
luaL_typename
[-0, +0, –]
const char *luaL_typename (lua_State *L, int index);
Returns the name of the type of the value at the given index.
luaL_unref
[-0, +0, –]
void luaL_unref (lua_State *L, int t, int ref);
Releases reference ref from the table at index t (see luaL_ref). The entry is removed from the table, so that the referred object can be collected. The reference ref is also freed to be used again.
If ref is LUA_NOREF or LUA_REFNIL, luaL_unref does nothing.
luaL_where
[-0, +1, e]
void luaL_where (lua_State *L, int lvl);
Pushes onto the stack a string identifying the current position of the control at level lvl in the call stack. Typically this string has the following format:
chunkname:currentline:
Level 0 is the running function, level 1 is the function that called the running function, etc.
This function is used to build a prefix for error messages.
6 – Standard Libraries
The standard Lua libraries provide useful functions that are implemented directly through the C API. Some of these functions provide essential services to the language (e.g., type andgetmetatable); others provide access to "outside" services (e.g., I/O); and others could be implemented in Lua itself, but are quite useful or have critical performance requirements that deserve an implementation in C (e.g., table.sort).
All libraries are implemented through the official C API and are provided as separate C modules. Currently, Lua has the following standard libraries:
- basic library (§6.1);
- coroutine library (§6.2);
- package library (§6.3);
- string manipulation (§6.4);
- table manipulation (§6.5);
- mathematical functions (§6.6) (sin, log, etc.);
- bitwise operations (§6.7);
- input and output (§6.8);
- operating system facilities (§6.9);
- debug facilities (§6.10).
Except for the basic and the package libraries, each library provides all its functions as fields of a global table or as methods of its objects.
To have access to these libraries, the C host program should call the luaL_openlibs function, which opens all standard libraries. Alternatively, the host program can open them individually by using luaL_requiref to call luaopen_base (for the basic library), luaopen_package (for the package library), luaopen_coroutine (for the coroutine library), luaopen_string(for the string library), luaopen_table (for the table library), luaopen_math (for the mathematical library), luaopen_bit32 (for the bit library), luaopen_io (for the I/O library),luaopen_os (for the Operating System library), and luaopen_debug (for the debug library). These functions are declared in lualib.h.
6.1 – Basic Functions
The basic library provides core functions to Lua. If you do not include this library in your application, you should check carefully whether you need to provide implementations for some of its facilities.
assert (v [, message])
Issues an error when the value of its argument v is false (i.e., nil or false); otherwise, returns all its arguments. message is an error message; when absent, it defaults to "assertion failed!"
collectgarbage ([opt [, arg]])
This function is a generic interface to the garbage collector. It performs different functions according to its first argument, opt:
- "
collect": performs a full garbage-collection cycle. This is the default option. - "
stop": stops automatic execution of the garbage collector. The collector will run only when explicitly invoked, until a call to restart it. - "
restart": restarts automatic execution of the garbage collector. - "
count": returns the total memory in use by Lua (in Kbytes) and a second value with the total memory in bytes modulo 1024. The first value has a fractional part, so the following equality is always true:k, b = collectgarbage("count") assert(k*1024 == math.floor(k)*1024 + b)(The second result is useful when Lua is compiled with a non floating-point type for numbers.)
- "
step": performs a garbage-collection step. The step "size" is controlled byarg(larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value ofarg. Returns true if the step finished a collection cycle. - "
setpause": setsargas the new value for the pause of the collector (see §2.5). Returns the previous value for pause. - "
setstepmul": setsargas the new value for the step multiplier of the collector (see §2.5). Returns the previous value for step. - "
isrunning": returns a boolean that tells whether the collector is running (i.e., not stopped). - "
generational": changes the collector to generational mode. This is an experimental feature (see §2.5). - "
incremental": changes the collector to incremental mode. This is the default mode.
dofile ([filename])
Opens the named file and executes its contents as a Lua chunk. When called without arguments, dofile executes the contents of the standard input (stdin). Returns all values returned by the chunk. In case of errors, dofile propagates the error to its caller (that is, dofile does not run in protected mode).
error (message [, level])
Terminates the last protected function called and returns message as the error message. Function error never returns.
Usually, error adds some information about the error position at the beginning of the message, if the message is a string. The level argument specifies how to get the error position. With level 1 (the default), the error position is where the error function was called. Level 2 points the error to where the function that called error was called; and so on. Passing a level 0 avoids the addition of error position information to the message.
_G
A global variable (not a function) that holds the global environment (see §2.2). Lua itself does not use this variable; changing its value does not affect any environment, nor vice-versa.
getmetatable (object)
If object does not have a metatable, returns nil. Otherwise, if the object's metatable has a "__metatable" field, returns the associated value. Otherwise, returns the metatable of the given object.
ipairs (t)
If t has a metamethod __ipairs, calls it with t as argument and returns the first three results from the call.
Otherwise, returns three values: an iterator function, the table t, and 0, so that the construction
for i,v in ipairs(t) do body end
will iterate over the pairs (1,t[1]), (2,t[2]), ..., up to the first integer key absent from the table.
load (ld [, source [, mode [, env]]])
Loads a chunk.
If ld is a string, the chunk is this string. If ld is a function, load calls it repeatedly to get the chunk pieces. Each call to ld must return a string that concatenates with previous results. A return of an empty string, nil, or no value signals the end of the chunk.
If there are no syntactic errors, returns the compiled chunk as a function; otherwise, returns nil plus the error message.
If the resulting function has upvalues, the first upvalue is set to the value of env, if that parameter is given, or to the value of the global environment. (When you load a main chunk, the resulting function will always have exactly one upvalue, the _ENV variable (see §2.2). When you load a binary chunk created from a function (see string.dump), the resulting function can have arbitrary upvalues.)
source is used as the source of the chunk for error messages and debug information (see §4.9). When absent, it defaults to ld, if ld is a string, or to "=(load)" otherwise.
The string mode controls whether the chunk can be text or binary (that is, a precompiled chunk). It may be the string "b" (only binary chunks), "t" (only text chunks), or "bt" (both binary and text). The default is "bt".
loadfile ([filename [, mode [, env]]])
Similar to load, but gets the chunk from file filename or from the standard input, if no file name is given.
next (table [, index])
Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. next returns the next index of the table and its associated value. When called with nil as its second argument, next returns an initial index and its associated value. When called with the last index, or with nil in an empty table, next returns nil. If the second argument is absent, then it is interpreted as nil. In particular, you can use next(t) to check whether a table is empty.
The order in which the indices are enumerated is not specified, even for numeric indices. (To traverse a table in numeric order, use a numerical for.)
The behavior of next is undefined if, during the traversal, you assign any value to a non-existent field in the table. You may however modify existing fields. In particular, you may clear existing fields.
pairs (t)
If t has a metamethod __pairs, calls it with t as argument and returns the first three results from the call.
Otherwise, returns three values: the next function, the table t, and nil, so that the construction
for k,v in pairs(t) do body end
will iterate over all key–value pairs of table t.
See function next for the caveats of modifying the table during its traversal.
pcall (f [, arg1, ···])
Calls function f with the given arguments in protected mode. This means that any error inside f is not propagated; instead, pcall catches the error and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In such case, pcall also returns all results from the call, after this first result. In case of any error, pcall returnsfalse plus the error message.
print (···)
Receives any number of arguments and prints their values to stdout, using the tostring function to convert each argument to a string. print is not intended for formatted output, but only as a quick way to show a value, for instance for debugging. For complete control over the output, use string.format and io.write.
rawequal (v1, v2)
Checks whether v1 is equal to v2, without invoking any metamethod. Returns a boolean.
rawget (table, index)
Gets the real value of table[index], without invoking any metamethod. table must be a table; index may be any value.
rawlen (v)
Returns the length of the object v, which must be a table or a string, without invoking any metamethod. Returns an integer number.
rawset (table, index, value)
Sets the real value of table[index] to value, without invoking any metamethod. table must be a table, index any value different from nil and NaN, and value any Lua value.
This function returns table.
select (index, ···)
If index is a number, returns all arguments after argument number index; a negative number indexes from the end (-1 is the last argument). Otherwise, index must be the string "#", andselect returns the total number of extra arguments it received.
setmetatable (table, metatable)
Sets the metatable for the given table. (You cannot change the metatable of other types from Lua, only from C.) If metatable is nil, removes the metatable of the given table. If the original metatable has a "__metatable" field, raises an error.
This function returns table.
tonumber (e [, base])
When called with no base, tonumber tries to convert its argument to a number. If the argument is already a number or a string convertible to a number (see §3.4.2), then tonumber returns this number; otherwise, it returns nil.
When called with base, then e should be a string to be interpreted as an integer numeral in that base. The base may be any integer between 2 and 36, inclusive. In bases above 10, the letter 'A' (in either upper or lower case) represents 10, 'B' represents 11, and so forth, with 'Z' representing 35. If the string e is not a valid numeral in the given base, the function returns nil.
tostring (v)
Receives a value of any type and converts it to a string in a reasonable format. (For complete control of how numbers are converted, use string.format.)
If the metatable of v has a "__tostring" field, then tostring calls the corresponding value with v as argument, and uses the result of the call as its result.
type (v)
Returns the type of its only argument, coded as a string. The possible results of this function are "nil" (a string, not the value nil), "number", "string", "boolean", "table", "function", "thread", and "userdata".
_VERSION
A global variable (not a function) that holds a string containing the current interpreter version. The current contents of this variable is "Lua 5.2".
xpcall (f, msgh [, arg1, ···])
This function is similar to pcall, except that it sets a new message handler msgh.
6.2 – Coroutine Manipulation
The operations related to coroutines comprise a sub-library of the basic library and come inside the table coroutine. See §2.6 for a general description of coroutines.
coroutine.create (f)
Creates a new coroutine, with body f. f must be a Lua function. Returns this new coroutine, an object with type "thread".
coroutine.resume (co [, val1, ···])
Starts or continues the execution of coroutine co. The first time you resume a coroutine, it starts running its body. The values val1, ... are passed as the arguments to the body function. If the coroutine has yielded, resume restarts it; the values val1, ... are passed as the results from the yield.
If the coroutine runs without any errors, resume returns true plus any values passed to yield (if the coroutine yields) or any values returned by the body function (if the coroutine terminates). If there is any error, resume returns false plus the error message.
coroutine.running ()
Returns the running coroutine plus a boolean, true when the running coroutine is the main one.
coroutine.status (co)
Returns the status of coroutine co, as a string: "running", if the coroutine is running (that is, it called status); "suspended", if the coroutine is suspended in a call to yield, or if it has not started running yet; "normal" if the coroutine is active but not running (that is, it has resumed another coroutine); and "dead" if the coroutine has finished its body function, or if it has stopped with an error.
coroutine.wrap (f)
Creates a new coroutine, with body f. f must be a Lua function. Returns a function that resumes the coroutine each time it is called. Any arguments passed to the function behave as the extra arguments to resume. Returns the same values returned by resume, except the first boolean. In case of error, propagates the error.
coroutine.yield (···)
Suspends the execution of the calling coroutine. Any arguments to yield are passed as extra results to resume.
6.3 – Modules
The package library provides basic facilities for loading modules in Lua. It exports one function directly in the global environment: require. Everything else is exported in a table package.
require (modname)
Loads the given module. The function starts by looking into the package.loaded table to determine whether modname is already loaded. If it is, then require returns the value stored atpackage.loaded[modname]. Otherwise, it tries to find a loader for the module.
To find a loader, require is guided by the package.searchers sequence. By changing this sequence, we can change how require looks for a module. The following explanation is based on the default configuration for package.searchers.
First require queries package.preload[modname]. If it has a value, this value (which should be a function) is the loader. Otherwise require searches for a Lua loader using the path stored in package.path. If that also fails, it searches for a C loader using the path stored in package.cpath. If that also fails, it tries an all-in-one loader (see package.searchers).
Once a loader is found, require calls the loader with two arguments: modname and an extra value dependent on how it got the loader. (If the loader came from a file, this extra value is the file name.) If the loader returns any non-nil value, require assigns the returned value to package.loaded[modname]. If the loader does not return a non-nil value and has not assigned any value to package.loaded[modname], then require assigns true to this entry. In any case, require returns the final value of package.loaded[modname].
If there is any error loading or running the module, or if it cannot find any loader for the module, then require raises an error.
package.config
A string describing some compile-time configurations for packages. This string is a sequence of lines:
- The first line is the directory separator string. Default is '
\' for Windows and '/' for all other systems. - The second line is the character that separates templates in a path. Default is '
;'. - The third line is the string that marks the substitution points in a template. Default is '
?'. - The fourth line is a string that, in a path in Windows, is replaced by the executable's directory. Default is '
!'. - The fifth line is a mark to ignore all text before it when building the
luaopen_function name. Default is '-'.
package.cpath
The path used by require to search for a C loader.
Lua initializes the C path package.cpath in the same way it initializes the Lua path package.path, using the environment variable LUA_CPATH_5_2 or the environment variableLUA_CPATH or a default path defined in luaconf.h.
package.loaded
A table used by require to control which modules are already loaded. When you require a module modname and package.loaded[modname] is not false, require simply returns the value stored there.
This variable is only a reference to the real table; assignments to this variable do not change the table used by require.
package.loadlib (libname, funcname)
Dynamically links the host program with the C library libname.
If funcname is "*", then it only links with the library, making the symbols exported by the library available to other dynamically linked libraries. Otherwise, it looks for a function funcnameinside the library and returns this function as a C function. So, funcname must follow the lua_CFunction prototype (see lua_CFunction).
This is a low-level function. It completely bypasses the package and module system. Unlike require, it does not perform any path searching and does not automatically adds extensions.libname must be the complete file name of the C library, including if necessary a path and an extension. funcname must be the exact name exported by the C library (which may depend on the C compiler and linker used).
This function is not supported by Standard C. As such, it is only available on some platforms (Windows, Linux, Mac OS X, Solaris, BSD, plus other Unix systems that support the dlfcnstandard).
package.path
The path used by require to search for a Lua loader.
At start-up, Lua initializes this variable with the value of the environment variable LUA_PATH_5_2 or the environment variable LUA_PATH or with a default path defined in luaconf.h, if those environment variables are not defined. Any ";;" in the value of the environment variable is replaced by the default path.
package.preload
A table to store loaders for specific modules (see require).
This variable is only a reference to the real table; assignments to this variable do not change the table used by require.
package.searchers
A table used by require to control how to load modules.
Each entry in this table is a searcher function. When looking for a module, require calls each of these searchers in ascending order, with the module name (the argument given to require) as its sole parameter. The function can return another function (the module loader) plus an extra value that will be passed to that loader, or a string explaining why it did not find that module (ornil if it has nothing to say).
Lua initializes this table with four searcher functions.
The first searcher simply looks for a loader in the package.preload table.
The second searcher looks for a loader as a Lua library, using the path stored at package.path. The search is done as described in function package.searchpath.
The third searcher looks for a loader as a C library, using the path given by the variable package.cpath. Again, the search is done as described in function package.searchpath. For instance, if the C path is the string
"./?.so;./?.dll;/usr/local/?/init.so"
the searcher for module foo will try to open the files ./foo.so, ./foo.dll, and /usr/local/foo/init.so, in that order. Once it finds a C library, this searcher first uses a dynamic link facility to link the application with the library. Then it tries to find a C function inside the library to be used as the loader. The name of this C function is the string "luaopen_" concatenated with a copy of the module name where each dot is replaced by an underscore. Moreover, if the module name has a hyphen, its prefix up to (and including) the first hyphen is removed. For instance, if the module name is a.v1-b.c, the function name will be luaopen_b_c.
The fourth searcher tries an all-in-one loader. It searches the C path for a library for the root name of the given module. For instance, when requiring a.b.c, it will search for a C library for a. If found, it looks into it for an open function for the submodule; in our example, that would be luaopen_a_b_c. With this facility, a package can pack several C submodules into one single library, with each submodule keeping its original open function.
All searchers except the first one (preload) return as the extra value the file name where the module was found, as returned by package.searchpath. The first searcher returns no extra value.
package.searchpath (name, path [, sep [, rep]])
Searches for the given name in the given path.
A path is a string containing a sequence of templates separated by semicolons. For each template, the function replaces each interrogation mark (if any) in the template with a copy of namewherein all occurrences of sep (a dot, by default) were replaced by rep (the system's directory separator, by default), and then tries to open the resulting file name.
For instance, if the path is the string
"./?.lua;./?.lc;/usr/local/?/init.lua"
the search for the name foo.a will try to open the files ./foo/a.lua, ./foo/a.lc, and /usr/local/foo/a/init.lua, in that order.
Returns the resulting name of the first file that it can open in read mode (after closing the file), or nil plus an error message if none succeeds. (This error message lists all file names it tried to open.)
6.4 – String Manipulation
This library provides generic functions for string manipulation, such as finding and extracting substrings, and pattern matching. When indexing a string in Lua, the first character is at position 1 (not at 0, as in C). Indices are allowed to be negative and are interpreted as indexing backwards, from the end of the string. Thus, the last character is at position -1, and so on.
The string library provides all its functions inside the table string. It also sets a metatable for strings where the __index field points to the string table. Therefore, you can use the string functions in object-oriented style. For instance, string.byte(s,i) can be written as s:byte(i).
The string library assumes one-byte character encodings.
string.byte (s [, i [, j]])
Returns the internal numerical codes of the characters s[i], s[i+1], ..., s[j]. The default value for i is 1; the default value for j is i. These indices are corrected following the same rules of function string.sub.
Numerical codes are not necessarily portable across platforms.
string.char (···)
Receives zero or more integers. Returns a string with length equal to the number of arguments, in which each character has the internal numerical code equal to its corresponding argument.
Numerical codes are not necessarily portable across platforms.
string.dump (function)
Returns a string containing a binary representation of the given function, so that a later load on this string returns a copy of the function (but with new upvalues).
string.find (s, pattern [, init [, plain]])
Looks for the first match of pattern in the string s. If it finds a match, then find returns the indices of s where this occurrence starts and ends; otherwise, it returns nil. A third, optional numerical argument init specifies where to start the search; its default value is 1 and can be negative. A value of true as a fourth, optional argument plain turns off the pattern matching facilities, so the function does a plain "find substring" operation, with no characters in pattern being considered magic. Note that if plain is given, then init must be given as well.
If the pattern has captures, then in a successful match the captured values are also returned, after the two indices.
string.format (formatstring, ···)
Returns a formatted version of its variable number of arguments following the description given in its first argument (which must be a string). The format string follows the same rules as the ANSI C function sprintf. The only differences are that the options/modifiers *, h, L, l, n, and p are not supported and that there is an extra option, q. The q option formats a string between double quotes, using escape sequences when necessary to ensure that it can safely be read back by the Lua interpreter. For instance, the call
string.format('%q', 'a string with "quotes" and \n new line')
may produce the string:
"a string with \"quotes\" and \
new line"
Options A and a (when available), E, e, f, G, and g all expect a number as argument. Options c, d, i, o, u, X, and x also expect a number, but the range of that number may be limited by the underlying C implementation. For options o, u, X, and x, the number cannot be negative. Option q expects a string; option s expects a string without embedded zeros. If the argument to option sis not a string, it is converted to one following the same rules of tostring.
string.gmatch (s, pattern)
Returns an iterator function that, each time it is called, returns the next captures from pattern over the string s. If pattern specifies no captures, then the whole match is produced in each call.
As an example, the following loop will iterate over all the words from string s, printing one per line:
s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
print(w)
end
The next example collects all pairs key=value from the given string into a table:
t = {}
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
t[k] = v
end
For this function, a caret '^' at the start of a pattern does not work as an anchor, as this would prevent the iteration.
string.gsub (s, pattern, repl [, n])
Returns a copy of s in which all (or the first n, if given) occurrences of the pattern have been replaced by a replacement string specified by repl, which can be a string, a table, or a function.gsub also returns, as its second value, the total number of matches that occurred. The name gsub comes from Global SUBstitution.
If repl is a string, then its value is used for replacement. The character % works as an escape character: any sequence in repl of the form %d, with d between 1 and 9, stands for the value of the d-th captured substring. The sequence %0 stands for the whole match. The sequence %% stands for a single %.
If repl is a table, then the table is queried for every match, using the first capture as the key.
If repl is a function, then this function is called every time a match occurs, with all captured substrings passed as arguments, in order.
In any case, if the pattern specifies no captures, then it behaves as if the whole pattern was inside a capture.
If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string).
Here are some examples:
x = string.gsub("hello world", "(%w+)", "%1 %1")
--> x="hello hello world world"
x = string.gsub("hello world", "%w+", "%0 %0", 1)
--> x="hello hello world"
x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
--> x="world hello Lua from"
x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
--> x="home = /home/roberto, user = roberto"
x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
return load(s)()
end)
--> x="4+5 = 9"
local t = {name="lua", version="5.2"}
x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
--> x="lua-5.2.tar.gz"
string.len (s)
Receives a string and returns its length. The empty string "" has length 0. Embedded zeros are counted, so "a\000bc\000" has length 5.
string.lower (s)
Receives a string and returns a copy of this string with all uppercase letters changed to lowercase. All other characters are left unchanged. The definition of what an uppercase letter is depends on the current locale.
string.match (s, pattern [, init])
Looks for the first match of pattern in the string s. If it finds one, then match returns the captures from the pattern; otherwise it returns nil. If pattern specifies no captures, then the whole match is returned. A third, optional numerical argument init specifies where to start the search; its default value is 1 and can be negative.
string.rep (s, n [, sep])
Returns a string that is the concatenation of n copies of the string s separated by the string sep. The default value for sep is the empty string (that is, no separator).
string.reverse (s)
Returns a string that is the string s reversed.
string.sub (s, i [, j])
Returns the substring of s that starts at i and continues until j; i and j can be negative. If j is absent, then it is assumed to be equal to -1 (which is the same as the string length). In particular, the call string.sub(s,1,j) returns a prefix of s with length j, and string.sub(s, -i) returns a suffix of s with length i.
If, after the translation of negative indices, i is less than 1, it is corrected to 1. If j is greater than the string length, it is corrected to that length. If, after these corrections, i is greater than j, the function returns the empty string.
string.upper (s)
Receives a string and returns a copy of this string with all lowercase letters changed to uppercase. All other characters are left unchanged. The definition of what a lowercase letter is depends on the current locale.
6.4.1 – Patterns
Character Class:
A character class is used to represent a set of characters. The following combinations are allowed in describing a character class:
- x: (where x is not one of the magic characters
^$()%.[]*+-?) represents the character x itself. .: (a dot) represents all characters.%a: represents all letters.%c: represents all control characters.%d: represents all digits.%g: represents all printable characters except space.%l: represents all lowercase letters.%p: represents all punctuation characters.%s: represents all space characters.%u: represents all uppercase letters.%w: represents all alphanumeric characters.%x: represents all hexadecimal digits.%x: (where x is any non-alphanumeric character) represents the character x. This is the standard way to escape the magic characters. Any punctuation character (even the non magic) can be preceded by a '%' when used to represent itself in a pattern.[set]: represents the class which is the union of all characters in set. A range of characters can be specified by separating the end characters of the range, in ascending order, with a '-', All classes%x described above can also be used as components in set. All other characters in set represent themselves. For example,[%w_](or[_%w]) represents all alphanumeric characters plus the underscore,[0-7]represents the octal digits, and[0-7%l%-]represents the octal digits plus the lowercase letters plus the '-' character.The interaction between ranges and classes is not defined. Therefore, patterns like
[%a-z]or[a-%%]have no meaning.[^set]: represents the complement of set, where set is interpreted as above.
For all classes represented by single letters (%a, %c, etc.), the corresponding uppercase letter represents the complement of the class. For instance, %S represents all non-space characters.
The definitions of letter, space, and other character groups depend on the current locale. In particular, the class [a-z] may not be equivalent to %l.
Pattern Item:
A pattern item can be
- a single character class, which matches any single character in the class;
- a single character class followed by '
*', which matches 0 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence; - a single character class followed by '
+', which matches 1 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence; - a single character class followed by '
-', which also matches 0 or more repetitions of characters in the class. Unlike '*', these repetition items will always match the shortest possible sequence; - a single character class followed by '
?', which matches 0 or 1 occurrence of a character in the class; %n, for n between 1 and 9; such item matches a substring equal to the n-th captured string (see below);%bxy, where x and y are two distinct characters; such item matches strings that start with x, end with y, and where the x and y are balanced. This means that, if one reads the string from left to right, counting +1 for an x and -1 for a y, the ending y is the first y where the count reaches 0. For instance, the item%b()matches expressions with balanced parentheses.%f[set], a frontier pattern; such item matches an empty string at any position such that the next character belongs to set and the previous character does not belong to set. The set set is interpreted as previously described. The beginning and the end of the subject are handled as if they were the character '\0'.
Pattern:
A pattern is a sequence of pattern items. A caret '^' at the beginning of a pattern anchors the match at the beginning of the subject string. A '$' at the end of a pattern anchors the match at the end of the subject string. At other positions, '^' and '$' have no special meaning and represent themselves.
Captures:
A pattern can contain sub-patterns enclosed in parentheses; they describe captures. When a match succeeds, the substrings of the subject string that match captures are stored (captured) for future use. Captures are numbered according to their left parentheses. For instance, in the pattern "(a*(.)%w(%s*))", the part of the string matching "a*(.)%w(%s*)" is stored as the first capture (and therefore has number 1); the character matching "." is captured with number 2, and the part matching "%s*" has number 3.
As a special case, the empty capture () captures the current string position (a number). For instance, if we apply the pattern "()aa()" on the string "flaaap", there will be two captures: 3 and 5.
6.5 – Table Manipulation
This library provides generic functions for table manipulation. It provides all its functions inside the table table.
Remember that, whenever an operation needs the length of a table, the table should be a proper sequence or have a __len metamethod (see §3.4.6). All functions ignore non-numeric keys in tables given as arguments.
For performance reasons, all table accesses (get/set) performed by these functions are raw.
table.concat (list [, sep [, i [, j]]])
Given a list where all elements are strings or numbers, returns the string list[i]..sep..list[i+1] ··· sep..list[j]. The default value for sep is the empty string, the default for iis 1, and the default for j is #list. If i is greater than j, returns the empty string.
table.insert (list, [pos,] value)
Inserts element value at position pos in list, shifting up the elements list[pos], list[pos+1], ···, list[#list]. The default value for pos is #list+1, so that a calltable.insert(t,x) inserts x at the end of list t.
table.pack (···)
Returns a new table with all parameters stored into keys 1, 2, etc. and with a field "n" with the total number of parameters. Note that the resulting table may not be a sequence.
table.remove (list [, pos])
Removes from list the element at position pos, returning the value of the removed element. When pos is an integer between 1 and #list, it shifts down the elements list[pos+1], list[pos+2], ···, list[#list] and erases element list[#list]; The index pos can also be 0 when #list is 0, or #list + 1; in those cases, the function erases the elementlist[pos].
The default value for pos is #list, so that a call table.remove(t) removes the last element of list t.
table.sort (list [, comp])
Sorts list elements in a given order, in-place, from list[1] to list[#list]. If comp is given, then it must be a function that receives two list elements and returns true when the first element must come before the second in the final order (so that not comp(list[i+1],list[i]) will be true after the sort). If comp is not given, then the standard Lua operator < is used instead.
The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.
table.unpack (list [, i [, j]])
Returns the elements from the given table. This function is equivalent to
return list[i], list[i+1], ···, list[j]
By default, i is 1 and j is #list.
6.6 – Mathematical Functions
This library is an interface to the standard C math library. It provides all its functions inside the table math.
math.abs (x)
Returns the absolute value of x.
math.acos (x)
Returns the arc cosine of x (in radians).
math.asin (x)
Returns the arc sine of x (in radians).
math.atan (x)
Returns the arc tangent of x (in radians).
math.atan2 (y, x)
Returns the arc tangent of y/x (in radians), but uses the signs of both parameters to find the quadrant of the result. (It also handles correctly the case of x being zero.)
math.ceil (x)
Returns the smallest integer larger than or equal to x.
math.cos (x)
Returns the cosine of x (assumed to be in radians).
math.cosh (x)
Returns the hyperbolic cosine of x.
math.deg (x)
Returns the angle x (given in radians) in degrees.
math.exp (x)
Returns the value ex.
math.floor (x)
Returns the largest integer smaller than or equal to x.
math.fmod (x, y)
Returns the remainder of the division of x by y that rounds the quotient towards zero.
math.frexp (x)
Returns m and e such that x = m2e, e is an integer and the absolute value of m is in the range [0.5, 1) (or zero when x is zero).
math.huge
The value HUGE_VAL, a value larger than or equal to any other numerical value.
math.ldexp (m, e)
Returns m2e (e should be an integer).
math.log (x [, base])
Returns the logarithm of x in the given base. The default for base is e (so that the function returns the natural logarithm of x).
math.max (x, ···)
Returns the maximum value among its arguments.
math.min (x, ···)
Returns the minimum value among its arguments.
math.modf (x)
Returns two numbers, the integral part of x and the fractional part of x.
math.pi
The value of π.
math.pow (x, y)
Returns xy. (You can also use the expression x^y to compute this value.)
math.rad (x)
Returns the angle x (given in degrees) in radians.
math.random ([m [, n]])
This function is an interface to the simple pseudo-random generator function rand provided by Standard C. (No guarantees can be given for its statistical properties.)
When called without arguments, returns a uniform pseudo-random real number in the range [0,1). When called with an integer number m, math.random returns a uniform pseudo-random integer in the range [1, m]. When called with two integer numbers m and n, math.random returns a uniform pseudo-random integer in the range [m, n].
math.randomseed (x)
Sets x as the "seed" for the pseudo-random generator: equal seeds produce equal sequences of numbers.
math.sin (x)
Returns the sine of x (assumed to be in radians).
math.sinh (x)
Returns the hyperbolic sine of x.
math.sqrt (x)
Returns the square root of x. (You can also use the expression x^0.5 to compute this value.)
math.tan (x)
Returns the tangent of x (assumed to be in radians).
math.tanh (x)
Returns the hyperbolic tangent of x.
6.7 – Bitwise Operations
This library provides bitwise operations. It provides all its functions inside the table bit32.
Unless otherwise stated, all functions accept numeric arguments in the range (-251,+251); each argument is normalized to the remainder of its division by 232 and truncated to an integer (in some unspecified way), so that its final value falls in the range [0,232 - 1]. Similarly, all results are in the range [0,232 - 1]. Note that bit32.bnot(0) is 0xFFFFFFFF, which is different from -1.
bit32.arshift (x, disp)
Returns the number x shifted disp bits to the right. The number disp may be any representable integer. Negative displacements shift to the left.
This shift operation is what is called arithmetic shift. Vacant bits on the left are filled with copies of the higher bit of x; vacant bits on the right are filled with zeros. In particular, displacements with absolute values higher than 31 result in zero or 0xFFFFFFFF (all original bits are shifted out).
bit32.band (···)
Returns the bitwise and of its operands.
bit32.bnot (x)
Returns the bitwise negation of x. For any integer x, the following identity holds:
assert(bit32.bnot(x) == (-1 - x) % 2^32)
bit32.bor (···)
Returns the bitwise or of its operands.
bit32.btest (···)
Returns a boolean signaling whether the bitwise and of its operands is different from zero.
bit32.bxor (···)
Returns the bitwise exclusive or of its operands.
bit32.extract (n, field [, width])
Returns the unsigned number formed by the bits field to field + width - 1 from n. Bits are numbered from 0 (least significant) to 31 (most significant). All accessed bits must be in the range [0, 31].
The default for width is 1.
bit32.replace (n, v, field [, width])
Returns a copy of n with the bits field to field + width - 1 replaced by the value v. See bit32.extract for details about field and width.
bit32.lrotate (x, disp)
Returns the number x rotated disp bits to the left. The number disp may be any representable integer.
For any valid displacement, the following identity holds:
assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))
In particular, negative displacements rotate to the right.
bit32.lshift (x, disp)
Returns the number x shifted disp bits to the left. The number disp may be any representable integer. Negative displacements shift to the right. In any direction, vacant bits are filled with zeros. In particular, displacements with absolute values higher than 31 result in zero (all bits are shifted out).
For positive displacements, the following equality holds:
assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
bit32.rrotate (x, disp)
Returns the number x rotated disp bits to the right. The number disp may be any representable integer.
For any valid displacement, the following identity holds:
assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))
In particular, negative displacements rotate to the left.
bit32.rshift (x, disp)
Returns the number x shifted disp bits to the right. The number disp may be any representable integer. Negative displacements shift to the left. In any direction, vacant bits are filled with zeros. In particular, displacements with absolute values higher than 31 result in zero (all bits are shifted out).
For positive displacements, the following equality holds:
assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
This shift operation is what is called logical shift.
6.8 – Input and Output Facilities
The I/O library provides two different styles for file manipulation. The first one uses implicit file descriptors; that is, there are operations to set a default input file and a default output file, and all input/output operations are over these default files. The second style uses explicit file descriptors.
When using implicit file descriptors, all operations are supplied by table io. When using explicit file descriptors, the operation io.open returns a file descriptor and then all operations are supplied as methods of the file descriptor.
The table io also provides three predefined file descriptors with their usual meanings from C: io.stdin, io.stdout, and io.stderr. The I/O library never closes these files.
Unless otherwise stated, all I/O functions return nil on failure (plus an error message as a second result and a system-dependent error code as a third result) and some value different from nil on success. On non-Posix systems, the computation of the error message and error code in case of errors may be not thread safe, because they rely on the global C variable errno.
io.close ([file])
Equivalent to file:close(). Without a file, closes the default output file.
io.flush ()
Equivalent to io.output():flush().
io.input ([file])
When called with a file name, it opens the named file (in text mode), and sets its handle as the default input file. When called with a file handle, it simply sets this file handle as the default input file. When called without parameters, it returns the current default input file.
In case of errors this function raises the error, instead of returning an error code.
io.lines ([filename ···])
Opens the given file name in read mode and returns an iterator function that works like file:lines(···) over the opened file. When the iterator function detects the end of file, it returns nil(to finish the loop) and automatically closes the file.
The call io.lines() (with no file name) is equivalent to io.input():lines(); that is, it iterates over the lines of the default input file. In this case it does not close the file when the loop ends.
In case of errors this function raises the error, instead of returning an error code.
io.open (filename [, mode])
This function opens a file, in the mode specified in the string mode. It returns a new file handle, or, in case of errors, nil plus an error message.
The mode string can be any of the following:
- "
r": read mode (the default); - "
w": write mode; - "
a": append mode; - "
r+": update mode, all previous data is preserved; - "
w+": update mode, all previous data is erased; - "
a+": append update mode, previous data is preserved, writing is only allowed at the end of file.
The mode string can also have a 'b' at the end, which is needed in some systems to open the file in binary mode.
io.output ([file])
Similar to io.input, but operates over the default output file.
io.popen (prog [, mode])
This function is system dependent and is not available on all platforms.
Starts program prog in a separated process and returns a file handle that you can use to read data from this program (if mode is "r", the default) or to write data to this program (if mode is"w").
io.read (···)
Equivalent to io.input():read(···).
io.tmpfile ()
Returns a handle for a temporary file. This file is opened in update mode and it is automatically removed when the program ends.
io.type (obj)
Checks whether obj is a valid file handle. Returns the string "file" if obj is an open file handle, "closed file" if obj is a closed file handle, or nil if obj is not a file handle.
io.write (···)
Equivalent to io.output():write(···).
file:close ()
Closes file. Note that files are automatically closed when their handles are garbage collected, but that takes an unpredictable amount of time to happen.
When closing a file handle created with io.popen, file:close returns the same values returned by os.execute.
file:flush ()
Saves any written data to file.
file:lines (···)
Returns an iterator function that, each time it is called, reads the file according to the given formats. When no format is given, uses "*l" as a default. As an example, the construction
for c in file:lines(1) do body end
will iterate over all characters of the file, starting at the current position. Unlike io.lines, this function does not close the file when the loop ends.
In case of errors this function raises the error, instead of returning an error code.
file:read (···)
Reads the file file, according to the given formats, which specify what to read. For each format, the function returns a string (or a number) with the characters read, or nil if it cannot read data with the specified format. When called without formats, it uses a default format that reads the next line (see below).
The available formats are
- "
*n": reads a number; this is the only format that returns a number instead of a string. - "
*a": reads the whole file, starting at the current position. On end of file, it returns the empty string. - "
*l": reads the next line skipping the end of line, returning nil on end of file. This is the default format. - "
*L": reads the next line keeping the end of line (if present), returning nil on end of file. - number: reads a string with up to this number of bytes, returning nil on end of file. If number is zero, it reads nothing and returns an empty string, or nil on end of file.
file:seek ([whence [, offset]])
Sets and gets the file position, measured from the beginning of the file, to the position given by offset plus a base specified by the string whence, as follows:
- "
set": base is position 0 (beginning of the file); - "
cur": base is current position; - "
end": base is end of file;
In case of success, seek returns the final file position, measured in bytes from the beginning of the file. If seek fails, it returns nil, plus a string describing the error.
The default value for whence is "cur", and for offset is 0. Therefore, the call file:seek() returns the current file position, without changing it; the call file:seek("set") sets the position to the beginning of the file (and returns 0); and the call file:seek("end") sets the position to the end of the file, and returns its size.
file:setvbuf (mode [, size])
Sets the buffering mode for an output file. There are three available modes:
- "
no": no buffering; the result of any output operation appears immediately. - "
full": full buffering; output operation is performed only when the buffer is full or when you explicitlyflushthe file (seeio.flush). - "
line": line buffering; output is buffered until a newline is output or there is any input from some special files (such as a terminal device).
For the last two cases, size specifies the size of the buffer, in bytes. The default is an appropriate size.
file:write (···)
Writes the value of each of its arguments to file. The arguments must be strings or numbers.
In case of success, this function returns file. Otherwise it returns nil plus a string describing the error.
6.9 – Operating System Facilities
This library is implemented through table os.
os.clock ()
Returns an approximation of the amount in seconds of CPU time used by the program.
os.date ([format [, time]])
Returns a string or a table containing date and time, formatted according to the given string format.
If the time argument is present, this is the time to be formatted (see the os.time function for a description of this value). Otherwise, date formats the current time.
If format starts with '!', then the date is formatted in Coordinated Universal Time. After this optional character, if format is the string "*t", then date returns a table with the following fields:year (four digits), month (1–12), day (1–31), hour (0–23), min (0–59), sec (0–61), wday (weekday, Sunday is 1), yday (day of the year), and isdst (daylight saving flag, a boolean). This last field may be absent if the information is not available.
If format is not "*t", then date returns the date as a string, formatted according to the same rules as the ANSI C function strftime.
When called without arguments, date returns a reasonable date and time representation that depends on the host system and on the current locale (that is, os.date() is equivalent toos.date("%c")).
On non-Posix systems, this function may be not thread safe because of its reliance on C function gmtime and C function localtime.
os.difftime (t2, t1)
Returns the number of seconds from time t1 to time t2. In POSIX, Windows, and some other systems, this value is exactly t2-t1.
os.execute ([command])
This function is equivalent to the ANSI C function system. It passes command to be executed by an operating system shell. Its first result is true if the command terminated successfully, or nilotherwise. After this first result the function returns a string and a number, as follows:
- "
exit": the command terminated normally; the following number is the exit status of the command. - "
signal": the command was terminated by a signal; the following number is the signal that terminated the command.
When called without a command, os.execute returns a boolean that is true if a shell is available.
os.exit ([code [, close])
Calls the ANSI C function exit to terminate the host program. If code is true, the returned status is EXIT_SUCCESS; if code is false, the returned status is EXIT_FAILURE; if code is a number, the returned status is this number. The default value for code is true.
If the optional second argument close is true, closes the Lua state before exiting.
os.getenv (varname)
Returns the value of the process environment variable varname, or nil if the variable is not defined.
os.remove (filename)
Deletes the file (or empty directory, on POSIX systems) with the given name. If this function fails, it returns nil, plus a string describing the error and the error code.
os.rename (oldname, newname)
Renames file or directory named oldname to newname. If this function fails, it returns nil, plus a string describing the error and the error code.
os.setlocale (locale [, category])
Sets the current locale of the program. locale is a system-dependent string specifying a locale; category is an optional string describing which category to change: "all", "collate","ctype", "monetary", "numeric", or "time"; the default category is "all". The function returns the name of the new locale, or nil if the request cannot be honored.
If locale is the empty string, the current locale is set to an implementation-defined native locale. If locale is the string "C", the current locale is set to the standard C locale.
When called with nil as the first argument, this function only returns the name of the current locale for the given category.
This function may be not thread safe because of its reliance on C function setlocale.
os.time ([table])
Returns the current time when called without arguments, or a time representing the date and time specified by the given table. This table must have fields year, month, and day, and may have fields hour (default is 12), min (default is 0), sec (default is 0), and isdst (default is nil). For a description of these fields, see the os.date function.
The returned value is a number, whose meaning depends on your system. In POSIX, Windows, and some other systems, this number counts the number of seconds since some given start time (the "epoch"). In other systems, the meaning is not specified, and the number returned by time can be used only as an argument to os.date and os.difftime.
os.tmpname ()
Returns a string with a file name that can be used for a temporary file. The file must be explicitly opened before its use and explicitly removed when no longer needed.
On POSIX systems, this function also creates a file with that name, to avoid security risks. (Someone else might create the file with wrong permissions in the time between getting the name and creating the file.) You still have to open the file to use it and to remove it (even if you do not use it).
When possible, you may prefer to use io.tmpfile, which automatically removes the file when the program ends.
6.10 – The Debug Library
This library provides the functionality of the debug interface (§4.9) to Lua programs. You should exert care when using this library. Several of its functions violate basic assumptions about Lua code (e.g., that variables local to a function cannot be accessed from outside; that userdata metatables cannot be changed by Lua code; that Lua programs do not crash) and therefore can compromise otherwise secure code. Moreover, some functions in this library may be slow.
All functions in this library are provided inside the debug table. All functions that operate over a thread have an optional first argument which is the thread to operate over. The default is always the current thread.
debug.debug ()
Enters an interactive mode with the user, running each string that the user enters. Using simple commands and other debug facilities, the user can inspect global and local variables, change their values, evaluate expressions, and so on. A line containing only the word cont finishes this function, so that the caller continues its execution.
Note that commands for debug.debug are not lexically nested within any function and so have no direct access to local variables.
debug.gethook ([thread])
Returns the current hook settings of the thread, as three values: the current hook function, the current hook mask, and the current hook count (as set by the debug.sethook function).
debug.getinfo ([thread,] f [, what])
Returns a table with information about a function. You can give the function directly or you can give a number as the value of f, which means the function running at level f of the call stack of the given thread: level 0 is the current function (getinfo itself); level 1 is the function that called getinfo (except for tail calls, which do not count on the stack); and so on. If f is a number larger than the number of active functions, then getinfo returns nil.
The returned table can contain all the fields returned by lua_getinfo, with the string what describing which fields to fill in. The default for what is to get all information available, except the table of valid lines. If present, the option 'f' adds a field named func with the function itself. If present, the option 'L' adds a field named activelines with the table of valid lines.
For instance, the expression debug.getinfo(1,"n").name returns a table with a name for the current function, if a reasonable name can be found, and the expressiondebug.getinfo(print) returns a table with all available information about the print function.
debug.getlocal ([thread,] f, local)
This function returns the name and the value of the local variable with index local of the function at level f of the stack. This function accesses not only explicit local variables, but also parameters, temporaries, etc.
The first parameter or local variable has index 1, and so on, until the last active variable. Negative indices refer to vararg parameters; -1 is the first vararg parameter. The function returns nil if there is no variable with the given index, and raises an error when called with a level out of range. (You can call debug.getinfo to check whether the level is valid.)
Variable names starting with '(' (open parenthesis) represent internal variables (loop control variables, temporaries, varargs, and C function locals).
The parameter f may also be a function. In that case, getlocal returns only the name of function parameters.
debug.getmetatable (value)
Returns the metatable of the given value or nil if it does not have a metatable.
debug.getregistry ()
Returns the registry table (see §4.5).
debug.getupvalue (f, up)
This function returns the name and the value of the upvalue with index up of the function f. The function returns nil if there is no upvalue with the given index.
debug.getuservalue (u)
Returns the Lua value associated to u. If u is not a userdata, returns nil.
debug.sethook ([thread,] hook, mask [, count])
Sets the given function as a hook. The string mask and the number count describe when the hook will be called. The string mask may have the following characters, with the given meaning:
- '
c': the hook is called every time Lua calls a function; - '
r': the hook is called every time Lua returns from a function; - '
l': the hook is called every time Lua enters a new line of code.
With a count different from zero, the hook is called after every count instructions.
When called without arguments, debug.sethook turns off the hook.
When the hook is called, its first parameter is a string describing the event that has triggered its call: "call" (or "tail call"), "return", "line", and "count". For line events, the hook also gets the new line number as its second parameter. Inside a hook, you can call getinfo with level 2 to get more information about the running function (level 0 is the getinfo function, and level 1 is the hook function).
debug.setlocal ([thread,] level, local, value)
This function assigns the value value to the local variable with index local of the function at level level of the stack. The function returns nil if there is no local variable with the given index, and raises an error when called with a level out of range. (You can call getinfo to check whether the level is valid.) Otherwise, it returns the name of the local variable.
See debug.getlocal for more information about variable indices and names.
debug.setmetatable (value, table)
Sets the metatable for the given value to the given table (which can be nil). Returns value.
debug.setupvalue (f, up, value)
This function assigns the value value to the upvalue with index up of the function f. The function returns nil if there is no upvalue with the given index. Otherwise, it returns the name of the upvalue.
debug.setuservalue (udata, value)
Sets the given value as the Lua value associated to the given udata. value must be a table or nil; udata must be a full userdata.
Returns udata.
debug.traceback ([thread,] [message [, level]])
If message is present but is neither a string nor nil, this function returns message without further processing. Otherwise, it returns a string with a traceback of the call stack. An optionalmessage string is appended at the beginning of the traceback. An optional level number tells at which level to start the traceback (default is 1, the function calling traceback).
debug.upvalueid (f, n)
Returns an unique identifier (as a light userdata) for the upvalue numbered n from the given function.
These unique identifiers allow a program to check whether different closures share upvalues. Lua closures that share an upvalue (that is, that access a same external local variable) will return identical ids for those upvalue indices.
debug.upvaluejoin (f1, n1, f2, n2)
Make the n1-th upvalue of the Lua closure f1 refer to the n2-th upvalue of the Lua closure f2.
7 – Lua Standalone
Although Lua has been designed as an extension language, to be embedded in a host C program, it is also frequently used as a standalone language. An interpreter for Lua as a standalone language, called simply lua, is provided with the standard distribution. The standalone interpreter includes all standard libraries, including the debug library. Its usage is:
lua [options] [script [args]]
The options are:
-e stat: executes string stat;-l mod: "requires" mod;-i: enters interactive mode after running script;-v: prints version information;-E: ignores environment variables;--: stops handling options;-: executesstdinas a file and stops handling options.
After handling its options, lua runs the given script, passing to it the given args as string arguments. When called without arguments, lua behaves as lua -v -i when the standard input (stdin) is a terminal, and as lua - otherwise.
When called without option -E, the interpreter checks for an environment variable LUA_INIT_5_2 (or LUA_INIT if it is not defined) before running any argument. If the variable content has the format @filename, then lua executes the file. Otherwise, lua executes the string itself.
When called with option -E, besides ignoring LUA_INIT, Lua also ignores the values of LUA_PATH and LUA_CPATH, setting the values of package.path and package.cpath with the default paths defined in luaconf.h.
All options are handled in order, except -i and -E. For instance, an invocation like
$ lua -e'a=1' -e 'print(a)' script.lua
will first set a to 1, then print the value of a, and finally run the file script.lua with no arguments. (Here $ is the shell prompt. Your prompt may be different.)
Before starting to run the script, lua collects all arguments in the command line in a global table called arg. The script name is stored at index 0, the first argument after the script name goes to index 1, and so on. Any arguments before the script name (that is, the interpreter name plus the options) go to negative indices. For instance, in the call
$ lua -la b.lua t1 t2
the interpreter first runs the file a.lua, then creates a table
arg = { [-2] = "lua", [-1] = "-la",
[0] = "b.lua",
[1] = "t1", [2] = "t2" }
and finally runs the file b.lua. The script is called with arg[1], arg[2], ... as arguments; it can also access these arguments with the vararg expression '...'.
In interactive mode, if you write an incomplete statement, the interpreter waits for its completion by issuing a different prompt.
In case of unprotected errors in the script, the interpreter reports the error to the standard error stream. If the error object is a string, the interpreter adds a stack traceback to it. Otherwise, if the error object has a metamethod __tostring, the interpreter calls this metamethod to produce the final message. Finally, if the error object is nil, the interpreter does not report the error.
When finishing normally, the interpreter closes its main Lua state (see lua_close). The script can avoid this step by calling os.exit to terminate.
To allow the use of Lua as a script interpreter in Unix systems, the standalone interpreter skips the first line of a chunk if it starts with #. Therefore, Lua scripts can be made into executable programs by using chmod +x and the #! form, as in
#!/usr/local/bin/lua
(Of course, the location of the Lua interpreter may be different in your machine. If lua is in your PATH, then
#!/usr/bin/env lua
is a more portable solution.)
8 – Incompatibilities with the Previous Version
Here we list the incompatibilities that you may find when moving a program from Lua 5.1 to Lua 5.2. You can avoid some incompatibilities by compiling Lua with appropriate options (see fileluaconf.h). However, all these compatibility options will be removed in the next version of Lua. Similarly, all features marked as deprecated in Lua 5.1 have been removed in Lua 5.2.
8.1 – Changes in the Language
- The concept of environment changed. Only Lua functions have environments. To set the environment of a Lua function, use the variable
_ENVor the functionload.C functions no longer have environments. Use an upvalue with a shared table if you need to keep shared state among several C functions. (You may use
luaL_setfuncsto open a C library with all functions sharing a common upvalue.)To manipulate the "environment" of a userdata (which is now called user value), use the new functions
lua_getuservalueandlua_setuservalue. - Lua identifiers cannot use locale-dependent letters.
- Doing a step or a full collection in the garbage collector does not restart the collector if it has been stopped.
- Weak tables with weak keys now perform like ephemeron tables.
- The event tail return in debug hooks was removed. Instead, tail calls generate a special new event, tail call, so that the debugger can know that there will not be a corresponding return event.
- Equality between function values has changed. Now, a function definition may not create a new value; it may reuse some previous value if there is no observable difference to the new function.
8.2 – Changes in the Libraries
- Function
moduleis deprecated. It is easy to set up a module with regular Lua code. Modules are not expected to set global variables. - Functions
setfenvandgetfenvwere removed, because of the changes in environments. - Function
math.log10is deprecated. Usemath.logwith 10 as its second argument, instead. - Function
loadstringis deprecated. Useloadinstead; it now accepts string arguments and are exactly equivalent toloadstring. - Function
table.maxnis deprecated. Write it in Lua if you really need it. - Function
os.executenow returns true when command terminates successfully and nil plus error information otherwise. - Function
unpackwas moved into the table library and therefore must be called astable.unpack. - Character class
%zin patterns is deprecated, as now patterns may contain '\0' as a regular character. - The table
package.loaderswas renamedpackage.searchers. - Lua does not have bytecode verification anymore. So, all functions that load code (
loadandloadfile) are potentially insecure when loading untrusted binary data. (Actually, those functions were already insecure because of flaws in the verification algorithm.) When in doubt, use themodeargument of those functions to restrict them to loading textual chunks. - The standard paths in the official distribution may change between versions.
8.3 – Changes in the API
- Pseudoindex
LUA_GLOBALSINDEXwas removed. You must get the global environment from the registry (see §4.5). - Pseudoindex
LUA_ENVIRONINDEXand functionslua_getfenv/lua_setfenvwere removed, as C functions no longer have environments. - Function
luaL_registeris deprecated. UseluaL_setfuncsso that your module does not create globals. (Modules are not expected to set global variables anymore.) - The
osizeargument to the allocation function may not be zero when creating a new block, that is, whenptrisNULL(seelua_Alloc). Use only the testptr == NULLto check whether the block is new. - Finalizers (
__gcmetamethods) for userdata are called in the reverse order that they were marked for finalization, not that they were created (see §2.5.1). (Most userdata are marked immediately after they are created.) Moreover, if the metatable does not have a__gcfield when set, the finalizer will not be called, even if it is set later. luaL_typerrorwas removed. Write your own version if you need it.- Function
lua_cpcallis deprecated. You can simply push the function withlua_pushcfunctionand call it withlua_pcall. - Functions
lua_equalandlua_lessthanare deprecated. Use the newlua_comparewith appropriate options instead. - Function
lua_objlenwas renamedlua_rawlen. - Function
lua_loadhas an extra parameter,mode. PassNULLto simulate the old behavior. - Function
lua_resumehas an extra parameter,from. PassNULLor the thread doing the call.
9 – The Complete Syntax of Lua
Here is the complete syntax of Lua in extended BNF. (It does not describe operator precedences.)
chunk ::= block
block ::= {stat} [retstat]
stat ::= ‘;’ |
varlist ‘=’ explist |
functioncall |
label |
break |
goto Name |
do block end |
while exp do block end |
repeat block until exp |
if exp then block {elseif exp then block} [else block] end |
for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end |
for namelist in explist do block end |
function funcname funcbody |
local function Name funcbody |
local namelist [‘=’ explist]
retstat ::= return [explist] [‘;’]
label ::= ‘::’ Name ‘::’
funcname ::= Name {‘.’ Name} [‘:’ Name]
varlist ::= var {‘,’ var}
var ::= Name | prefixexp ‘[’ exp ‘]’ | prefixexp ‘.’ Name
namelist ::= Name {‘,’ Name}
explist ::= exp {‘,’ exp}
exp ::= nil | false | true | Number | String | ‘...’ | functiondef |
prefixexp | tableconstructor | exp binop exp | unop exp
prefixexp ::= var | functioncall | ‘(’ exp ‘)’
functioncall ::= prefixexp args | prefixexp ‘:’ Name args
args ::= ‘(’ [explist] ‘)’ | tableconstructor | String
functiondef ::= function funcbody
funcbody ::= ‘(’ [parlist] ‘)’ block end
parlist ::= namelist [‘,’ ‘...’] | ‘...’
tableconstructor ::= ‘{’ [fieldlist] ‘}’
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp
fieldsep ::= ‘,’ | ‘;’
binop ::= ‘+’ | ‘-’ | ‘*’ | ‘/’ | ‘^’ | ‘%’ | ‘..’ |
‘<’ | ‘<=’ | ‘>’ | ‘>=’ | ‘==’ | ‘~=’ |
and | or
unop ::= ‘-’ | not | ‘#’
Last update: Thu Mar 21 13:01:53 BRT 2013
中文版最近更新: 2013-08-12 13:04
- 1. css參考手冊
- 2. 參考手冊
- 3. tolua++ 參考手冊
- 4. npm-參考手冊
- 5. thymeleaf參考手冊
- 6. LLVM language 參考手冊（譯）（3）
- 7. LLVM language 參考手冊（譯）（1）
- 8. LLVM language 參考手冊（譯）（4）
- 9. LLVM language 參考手冊（譯）（5）
- 10. Android編譯系統參考手冊
- 更多相關文章...
- • XQuery 參考手冊 - XQuery 教程
- • RSS 參考手冊 - RSS 教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • Flink 數據傳輸及反壓詳解
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. css參考手冊
- 2. 參考手冊
- 3. tolua++ 參考手冊
- 4. npm-參考手冊
- 5. thymeleaf參考手冊
- 6. LLVM language 參考手冊（譯）（3）
- 7. LLVM language 參考手冊（譯）（1）
- 8. LLVM language 參考手冊（譯）（4）
- 9. LLVM language 參考手冊（譯）（5）
- 10. Android編譯系統參考手冊