Luaref

1 簡介 luaref-intro

2 語言 lua-language

2.1 詞法約定 lua-lexical

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

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

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

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

2.2 值和類型 lua-values

2.2.1 強制轉型 lua-coercion

2.3 變數 lua-variables

var ::= Name

var ::= prefixexp [ exp ]

var ::= prefixexp . Name

gettable_event(_env, "x")

2.4 陳述式 lua-statement

2.4.1 程式碼塊 lua-chunk

chunk ::= {stat [ ; ]}

2.4.2 區塊 lua-block

block ::= chunk

stat ::= do block end

2.4.3 賦值 lua-assign

stat ::= varlist1 = explist1
varlist1 ::= var { , var }
explist1 ::= exp { , exp }

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

x, y = y, x

settable_event(_env, "x", val)

2.4.4 控制結構 lua-control

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

2.4.5 For 陳述式 for lua-for

stat ::=  for  Name = exp , exp [ , exp ] 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
     block
     var  =  var  +  step
  end
end

stat ::=  for  namelist in explist1 do block end
namelist ::= Name { , Name }

do
  local  f, s, var  =  explist
  while true do
      local  var1, ..., varn  =  f(s, var)
      var  =  var1
      if  var  == nil then break end
      block
  end
end

2.4.6 函式呼叫作為陳述式 lua-funcstatement

stat ::= functioncall

2.4.7 區域宣告 lua-local

stat ::=  local  namelist [ = explist1 ]
namelist ::= Name { , Name }

2.5 表達式 lua-expressions

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

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

2.5.1 算術運算子 lua-arithmetic

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

2.5.2 關係運算子 lua-relational

==    ~=    <     >     <=    >=

2.5.3 邏輯運算子 lua-logicalop

and    or    not

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

2.5.4 串聯 lua-concat

2.5.5 長度運算子 lua-# lua-length

2.5.6 優先順序 lua-precedence

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

2.5.7 表格建構式 lua-tableconstructor

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

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            -- temp["x"] = 1
  t[3] = f(x)        -- 3rd exp
  t[30] = 23
  t[4] = 45          -- 4th exp
  a = t
end

2.5.8 函式呼叫 lua-function

functioncall ::= prefixexp args

functioncall ::= prefixexp : Name args

args ::=  ( [ explist1 ] )
args ::= tableconstructor
args ::= String

a = f
(g).x(a)

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

2.5.9 函式定義 lua-function-define

function ::= function funcbody
funcbody ::= ( [ parlist1 ] ) block end

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

parlist1 ::= namelist [ , ... ] | ...

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

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

2.6 可見性規則 lua-visibility

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

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

2.7 錯誤處理 lua-errors

2.8 元表 metatable lua-metatable

metatable(obj)[event]

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

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

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

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

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

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

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

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

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

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

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

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

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.9 環境 lua-environments

2.10 垃圾收集 lua-gc

2.10.1 垃圾收集元方法 lua-gc-meta

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

2.10.2 - 弱表格 lua-weaktable

2.11 協程 lua-coroutine

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

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

3 應用程式介面 lua-API

3.1 堆疊 lua-stack lua-apiStack

3.2 堆疊大小 lua-apiStackSize

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

3.3 偽索引 lua-pseudoindex

lua_getfield(L, LUA_GLOBALSINDEX, varname);

3.4 C 閉包 lua-cclosure

3.5 登錄表 lua-registry

3.6 C 中的錯誤處理 lua-apiError

3.7 函式和類型 lua-apiFunctions

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

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);
}

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);

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

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

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

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

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 */
}

int lua_checkstack (lua_State *L, int extra);

void lua_close (lua_State *L);

void lua_concat (lua_State *L, int n);

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

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

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

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

int lua_error (lua_State *L);

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

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

void lua_getfenv (lua_State *L, int index);

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

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

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

int lua_getmetatable (lua_State *L, int index);

void lua_gettable (lua_State *L, int index);

int lua_gettop (lua_State *L);

void lua_insert (lua_State *L, int index);

typedef ptrdiff_t lua_Integer;

int lua_isboolean (lua_State *L, int index);

int lua_iscfunction (lua_State *L, int index);

int lua_isfunction (lua_State *L, int index);

int lua_islightuserdata (lua_State *L, int index);

int lua_isnil (lua_State *L, int index);

int lua_isnumber (lua_State *L, int index);

int lua_isstring (lua_State *L, int index);

int lua_istable (lua_State *L, int index);

int lua_isthread (lua_State *L, int index);

int lua_isuserdata (lua_State *L, int index);

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

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

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

void lua_newtable (lua_State *L);

lua_State *lua_newthread (lua_State *L);

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

int lua_next (lua_State *L, int index);

/* 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);
}

typedef double lua_Number;

size_t lua_objlen (lua_State *L, int index);

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

void lua_pop (lua_State *L, int n);

void lua_pushboolean (lua_State *L, int b);

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

void lua_pushcfunction (lua_State *L, lua_CFunction f);

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

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

void lua_pushinteger (lua_State *L, lua_Integer n);

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

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

void lua_pushnil (lua_State *L);

void lua_pushnumber (lua_State *L, lua_Number n);

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

int lua_pushthread (lua_State *L);

void lua_pushvalue (lua_State *L, int index);

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

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

void lua_rawget (lua_State *L, int index);

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

void lua_rawset (lua_State *L, int index);

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

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

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

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

void lua_remove (lua_State *L, int index);

void lua_replace (lua_State *L, int index);

int lua_resume (lua_State *L, int narg);

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

int lua_setfenv (lua_State *L, int index);

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

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

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

int lua_setmetatable (lua_State *L, int index);

void lua_settable (lua_State *L, int index);

void lua_settop (lua_State *L, int index);

typedef struct lua_State lua_State;

int lua_status (lua_State *L);

int lua_toboolean (lua_State *L, int index);

lua_CFunction lua_tocfunction (lua_State *L, int index);

lua_Integer lua_tointeger (lua_State *L, int idx);

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

lua_Number lua_tonumber (lua_State *L, int index);

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

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

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

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

int lua_type (lua_State *L, int index);

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

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

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

int lua_yield (lua_State *L, int nresults);

return lua_yield (L, nresults);

lua_pushvalue(L, 3)    --> 10 20 30 40 50 30*
lua_pushvalue(L, -1)   --> 10 20 30 40 50 30 30*
lua_remove(L, -3)      --> 10 20 30 40 30 30*
lua_remove(L,  6)      --> 10 20 30 40 30*
lua_insert(L,  1)      --> 30 10 20 30 40*
lua_insert(L, -1)      --> 30 10 20 30 40*  (no effect)
lua_replace(L, 2)      --> 30 40 20 30*
lua_settop(L, -3)      --> 30 40*
lua_settop(L,  6)      --> 30 40 nil nil nil nil*

3.8 除錯介面 lua-apiDebug

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

lua_Hook lua_gethook (lua_State *L);

int lua_gethookcount (lua_State *L);

int lua_gethookmask (lua_State *L);

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

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

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

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

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

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

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

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

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

int listvars (lua_State *L, int level) {
  lua_Debug ar;
  int i;
  const char *name;
  if (lua_getstack(L, level, &ar) == 0)
    return 0;  /* failure: no such level in the stack */
  i = 1;
  while ((name = lua_getlocal(L, &ar, i++)) != NULL) {
    printf("local %d %s\n", i-1, name);
    lua_pop(L, 1);  /* remove variable value */
  }
  lua_getinfo(L, "f", &ar);  /* retrieves function */
  i = 1;
  while ((name = lua_getupvalue(L, -1, i++)) != NULL) {
    printf("upvalue %d %s\n", i-1, name);
    lua_pop(L, 1);  /* remove upvalue value */
  }
  return 1;
}

4 輔助函式庫 lua-aux

4.1 函式和型別 lua-auxFunctions

void luaL_addchar (luaL_Buffer *B, char c);

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

void luaL_addsize (luaL_Buffer *B, size_t n);

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

void luaL_addvalue (luaL_Buffer *B);

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

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

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

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

typedef struct luaL_Buffer luaL_Buffer;

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

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

void luaL_checkany (lua_State *L, int narg);

int luaL_checkint (lua_State *L, int narg);

lua_Integer luaL_checkinteger (lua_State *L, int narg);

long luaL_checklong (lua_State *L, int narg);

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

lua_Number luaL_checknumber (lua_State *L, int narg);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lua_State *luaL_newstate (void);

void luaL_openlibs (lua_State *L);

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

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

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

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

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

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

char *luaL_prepbuffer (luaL_Buffer *B);

void luaL_pushresult (luaL_Buffer *B);

int luaL_ref (lua_State *L, int t);

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

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

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

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

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

void luaL_where (lua_State *L, int lvl);

5 標準程式庫 lua-lib

5.1 基本函數 lua-lib-core

assert(loadstring(s))()

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

5.2 協同程式操作 lua-lib-coroutine

5.3 模組 lua-modules

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

5.4 字串操作 lua-lib-string

string.format('%q', 'a string with "quotes" and \n new line')

"a string with \"quotes\" and \
 new line"

s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
  print(w)
end

t = {}
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
  t[k] = v
end

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 loadstring(s)()
    end)
--> x="4+5 = 9"
local t = {name="lua", version="5.1"}
x = string.gsub("$name%-$version.tar.gz", "%$(%w+)", t)
--> x="lua-5.1.tar.gz"

5.4.1 樣式 lua-patterns

樣式項目 lua-patternitem

模式 lua-pattern

捕獲 lua-capture

5.5 表格操作 lua-lib-table

5.6 數學函式 lua-lib-math

5.6 輸入和輸出工具 lua-lib-io

5.8 作業系統工具 lua-lib-os

5.9 除錯函式庫 lua-lib-debug

參考書目 lua-ref-bibliography

B 版權與授權 lua-ref-copyright

C LUAREF 文件 lua-ref-doc