Lua Lua 5.1 ��ե���󥹥ޥ˥奢��

Copyright ��� 2006 Lua.org, PUC-Rio. All rights reserved.

�ܼ�

����

�ؿ�

_G
_VERSION
assert
collectgarbage
coroutine.create
coroutine.resume
coroutine.running
coroutine.status
coroutine.wrap
coroutine.yield
debug.debug
debug.getfenv
debug.gethook
debug.getinfo
debug.getlocal
debug.getmetatable
debug.getregistry
debug.getupvalue
debug.setfenv
debug.sethook
debug.setlocal
debug.setmetatable
debug.setupvalue
debug.traceback
dofile
error
file:close
file:flush
file:lines
file:read
file:seek
file:setvbuf
file:write
getfenv
getmetatable
io.close
io.flush
io.input
io.lines
io.open
io.output
io.popen
io.read
io.tmpfile
io.type
io.write
ipairs
load
loadfile
loadstring
math.abs
math.acos
math.asin
math.atan2
math.atan
math.ceil
math.cosh
math.cos
math.deg
math.exp
math.floor
math.fmod
math.frexp
math.ldexp
math.log10
math.log
math.max
math.min
math.modf
math.pow
math.rad
math.random
math.randomseed
math.sinh
math.sin
math.sqrt
math.tanh
math.tan
module
next
os.clock
os.date
os.difftime
os.execute
os.exit
os.getenv
os.remove
os.rename
os.setlocale
os.time
os.tmpname
package.cpath
package.loaded
package.loadlib
package.path
package.preload
package.seeall
pairs
pcall
print
rawequal
rawget
rawset
require
select
setfenv
setmetatable
string.byte
string.char
string.dump
string.find
string.format
string.gmatch
string.gsub
string.len
string.lower
string.match
string.rep
string.reverse
string.sub
string.upper
table.concat
table.insert
table.maxn
table.remove
table.sort
tonumber
tostring
type
unpack
xpcall

API

lua_Alloc
lua_CFunction
lua_Debug
lua_Hook
lua_Integer
lua_Number
lua_Reader
lua_State
lua_Writer
lua_atpanic
lua_call
lua_checkstack
lua_close
lua_concat
lua_cpcall
lua_createtable
lua_dump
lua_equal
lua_error
lua_gc
lua_getallocf
lua_getfenv
lua_getfield
lua_getglobal
lua_gethook
lua_gethookcount
lua_gethookmask
lua_getinfo
lua_getlocal
lua_getmetatable
lua_getstack
lua_gettable
lua_gettop
lua_getupvalue
lua_insert
lua_isboolean
lua_iscfunction
lua_isfunction
lua_islightuserdata
lua_isnil
lua_isnumber
lua_isstring
lua_istable
lua_isthread
lua_isuserdata
lua_lessthan
lua_load
lua_newstate
lua_newtable
lua_newthread
lua_newuserdata
lua_next
lua_objlen
lua_pcall
lua_pop
lua_pushboolean
lua_pushcclosure
lua_pushcfunction
lua_pushfstring
lua_pushinteger
lua_pushlightuserdata
lua_pushlstring
lua_pushnil
lua_pushnumber
lua_pushstring
lua_pushthread
lua_pushvalue
lua_pushvfstring
lua_rawequal
lua_rawget
lua_rawgeti
lua_rawset
lua_rawseti
lua_register
lua_remove
lua_replace
lua_resume
lua_setallocf
lua_setfenv
lua_setfield
lua_setglobal
lua_sethook
lua_setlocal
lua_setmetatable
lua_settable
lua_settop
lua_setupvalue
lua_status
lua_toboolean
lua_tocfunction
lua_tointeger
lua_tolstring
lua_tonumber
lua_topointer
lua_tostring
lua_tothread
lua_touserdata
lua_type
lua_typename
lua_xmove
lua_yield

����饤�֥��

luaL_Buffer
luaL_Reg
luaL_addchar
luaL_addlstring
luaL_addsize
luaL_addstring
luaL_addvalue
luaL_argcheck
luaL_argerror
luaL_buffinit
luaL_callmeta
luaL_checkany
luaL_checkint
luaL_checkinteger
luaL_checklong
luaL_checklstring
luaL_checknumber
luaL_checkoption
luaL_checkstack
luaL_checkstring
luaL_checktype
luaL_checkudata
luaL_error
luaL_getmetafield
luaL_getmetatable
luaL_gsub
luaL_loadbuffer
luaL_loadfile
luaL_loadstring
luaL_newmetatable
luaL_newstate
luaL_openlibs
luaL_optint
luaL_optinteger
luaL_optlong
luaL_optlstring
luaL_optnumber
luaL_optstring
luaL_prepbuffer
luaL_pushresult
luaL_ref
luaL_register
luaL_typename
luaL_typerror
luaL_unref
luaL_where


�ǽ�����: Fri Feb 10 17:15:37 BRST 2006

Lua 5.1 ��ե���󥹥ޥ˥奢��

by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes

Copyright ��� 2006 Lua.org, PUC-Rio. All rights reserved.


0 - ���ܸ����ˤĤ���

����ʸ��ϡ� Lua 5.1 Reference Manual �����Ԥ�̵�Ǥ����ܸ����������������� Lua 5.1 ��ե���󥹥ޥ˥奢��Ǥ��롣

1 - ����

Lua�ϳ�ĥ�ץ�����ߥ󥰸���Ǥ��롣 �ǡ������ҵ�ǽ����������Ѥμ�³�����ץ�����ߥ󥰤򥵥ݡ��Ȥ���褦�ǥ����󤵤줿�� ���֥������Ȼظ��ץ�����ߥ󥰡��ؿ����ץ�����ߥ󥰡��ǡ�����ư���ץ�����ߥ󥰤⥵�ݡ��Ȥ��Ƥ��롣 Lua�ϡ��ѥ�ե�Ƿڤ�������ץȸ���Ȥ��ơ�����餬ɬ�פʤ�����ץ������˻Ȥ��뤳�Ȥ�տޤ��Ƥ��롣 Lua�� ���꡼��� C (�ĤޤꡢANSI C �� C++ �ζ��̤Υ��֥��å�) �ǽ񤫤졢�饤�֥��Ȥ��Ƽ�������Ƥ��롣

��ĥ����Ǥ��뤿�ᡢLua�ϡ֥ᥤ��ץץ�����������ʤ��� �ۥ��ȥ��饤����� (����٥åǥ��󥰥ץ�����������뤤��ñ���ۥ��� �Ȥ�Ƥ�) �� �Ȥ߹��ޤ�� ư�������Ǥ��롣 ���Υۥ��ȥץ������ϡ�Lua�����ɤ�¹Ԥ���ؿ���ƤӽФ����ꡢLua���ѿ����ɤ߽񤭤����ꡢLua����ƤФ��C�δؿ�����Ͽ������Ǥ��롣 C�δؿ���Ȥäƥ������ޥ������뤳�Ȥǡ����̤ι�ʸ����ĥץ�����ߥ󥰸�����͡����ΰ���ϰϤ˥��С����뤳�Ȥ��Ǥ��롣 Lua�Υǥ����ȥ�ӥ塼�����ˤ� lua �ȸƤФ�륵��ץ�Υۥ��ȥץ�����ब�ޤޤ�Ƥ��롣 �����Lua�饤�֥���Ȥä������ʥ�����ɥ������Lua���󥿥ץ꥿���󶡤��Ƥ��롣

Lua�ϥե꡼���եȥ������Ǥ��ꡢ�饤���󥹤ˤ�񤫤�Ƥ���褦�ˡ������ʤ��ݾڤ�ʤ����뤬�ޤ��󶡤���롣 ���Υޥ˥奢��˵��Ҥ���Ƥ��������Lua�θ��������֥����� www.lua.org ���󶡤���Ƥ��롣

¾�Τ��٤ƤΥ�ե���󥹥ޥ˥奢���Ʊ�͡�����ʸ��Ϥ���������̵̣����Ǥ��롣 Lua�Υǥ�������ظ�ˤ������ˤĤ��Ƥε����ϡ�Lua�Υ����֥����Ȥˤ��뵻��ʸ��򻲾ȤΤ��ȡ� Lua�ˤ��ץ�����ߥ󥰤ξܤ����Ҳ�ϡ�Roberto�� Programming in Lua �򻲾ȡ�

2 - ����

���Υ��������Ǥϡ�Lua�λ��硢��ʸ����̣���ˤĤ��Ƶ��Ҥ��롣 ����������ȡ����Υ��������Ǥϡ��ɤ����ä��ȡ�����ͭ������������ɤ��Ȥ߹�碌����Τ��������Ƥ����Ȥ߹�碌�ϲ����̣����Τ��ˤĤ��Ƶ��Ҥ��Ƥ��롣

���칽¤�ϰ���Ū�ʳ�ĥBNF��ˡ��Ȥä��������롣 {a} �� a ��0��ʾ�η����֤���[a] �� a ����ά��ǽ�Ǥ��뤳�Ȥ�ɽ���� ��ü����� italic ��ɽ���졢������ɤ� bold��¾�ν�ü����ϥ��󥰥륯�����ȤǰϤޤ줿 type writer �ե���Ȥ�ɽ������롣 Lua�δ����ʹ�ʸ�Ϥ��Υޥ˥奢��κǸ�ˤ��롣

2.1 - ������

Lua�� ̾�� (���̻� �Ȥ�ƤФ��) �ϡ�ʸ��������������������������Ȥ߹�碌��Ǥ�դ�ʸ����Ǥ��롣 �����������ǻϤޤäƤϤʤ�ʤ��� �����¿���θ����̾��������˰��פ��롣 ��ʸ���פ�����ϸ��ߤΥ�������˰�¸���롣 ���ߤΥ�������ǥ���ե��٥åȤȤߤʤ����ʸ���Ϥɤ�⼱�̻Ҥ˻Ȥ��롣 ���̻Ҥ�̾���ѿ���ơ��֥�ե�����ɤ˻Ȥ��롣

�ʲ��� ������� ��ͽ�󤵤�Ƥ��ꡢ̾���Ȥ��ƤϻȤ��ʤ���

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

Lua ����ʸ����ʸ������̤������Ǥ��롣 and ��ͽ��������And �� AND �ϡ�2�Ĥΰۤʤä���ͭ����̾���Ǥ��롣 ����Ū�ˡ������������������ʸ���ǻϤޤ�̾�� (�㤨�� _VERSION) �ϡ� Lua���Ȥ������Υ������Х��ѿ��Ȥ���ͽ�󤵤�Ƥ��롣

�ʲ���ʸ����ϡ�����¾�Υȡ�����Ǥ��롣

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

ʸ�����ƥ�� ���Фˤʤ륷�󥰥륯�����Ȥ����֥륯�����ȤǰϤޤ졢 �ʲ��� C �Τ褦�ʥ��������ץ������󥹤�ޤळ�Ȥ��Ǥ��롣

�嵭�˲ä��ơ� `\������ (�Хå�����å������ʪ�β��Ԥ�³�������) �򵭽Ҥ���ʸ������˲��Ԥ�ޤ�뤳�Ȥ��Ǥ��롣 ����� `\ddd�� (ddd�Ϻ���3���10�ʿ�) �Ȥ������������ץ������󥹤�Ȥä� ʸ�������ʸ���򤽤Υ������ͤǻ��ꤹ�뤳�Ȥ�Ǥ��롣 (���ͥ��������פθ�˿�����³�����ϡ��Ԥä���3��Ȥä�ɽ�����ʤ���Фʤ�ʤ���) Lua��ʸ����� `\0�� ��ɽ����를����ޤߡ������ʤ�8�ӥå��ͤ�ޤळ�Ȥ��Ǥ��롣

���֥�(�ޤ��ϥ��󥰥�)�������ȤǰϤޤ줿ʸ�����ƥ�����ˡ� ���֥�(�ޤ��ϥ��󥰥�)�������ȡ����ԡ��Хå�����å��塢�ޤ��������ޤ줿�������֤�����ˤϡ� ���������ץ������󥹤�Ȥ�ʤ���Фʤ�ʤ��� ¾�Τ��٤Ƥ�ʸ����ľ�ܥ�ƥ����������ƹ���ʤ� (�ե����륷���ƥ���Ф��Ƥ�����ʸ��������򵯤������⤷��ʤ�����Lua������פǤ��롣)

ʸ�����ƥ��� Ĺ��� �ǰϤ�Ĺ��������Ȥä�������뤳�Ȥ�Ǥ��롣 n �ʤγ���Ĺ��� �ϡ� �����ѳ�̤� n �ĤΥ�������ȡ�����˳����ѳ�̤�³������ΤǤ��롣 �Ĥޤꡢ0�ʤγ���Ĺ��̤� [[ �Ƚ񤭡� 1�ʤγ���Ĺ��̤� [=[ �Ƚ񤭡��ʲ�Ʊ�ͤǤ��롣 �Ĥ�Ĺ��� ��Ʊ�ͤǤ��롣 �㤨��4�ʤ��Ĥ�Ĺ��̤� ]====] �Ƚ񤯡� Ĺ��ʸ�����Ǥ�դ��ʿ��γ���Ĺ��̤ǻϤޤꡢƱ���ʿ����Ĥ�Ĺ��̤ǽ���롣 ���γѥ��å������Υ�ƥ��ϡ�ʣ���Ԥ��ϤäƵ��ҤǤ��롣 ���������ץ������󥹤ϰ��ڲ�ᤵ�줺���ۤʤ��ʿ����Ĥ�Ĺ��̤�̵�뤹�롣 ����ϡ��������ʿ����Ĥ�Ĺ��̤������ޤ줿�����ʳ���Ǥ�դ����Ƥ�������롣

�����ʤ褦�ˡ�����Ĺ��̤Τ�����˲��Ԥ�³�����Ȥ��ϡ����β��Ԥ�ʸ����˴ޤޤ�ʤ��� �㤨�С�ASCII (�Ĥޤ� `a�� ��97�����Ԥ�10��`1�� ��49�Ǥ���褦��ʸ��������) ���Ȥ��Ƥ��륷���ƥ�Ǥϡ� �ʲ���4�ĤΥ�ƥ���Ʊ��ʸ�����ɽ�����Ƥ��롣

      (1)   'alo\n123"'
      (2)   "alo\n123\""
      (3)   '\97lo\10\04923"'
      (4)   [[alo
            123"]]
      (5)   [==[
            alo
            123"]==]

������� �ˤϾ�ά��ǽ�ʾ������Ⱦ�ά��ǽ�ʻؿ�����񤯤��Ȥ��Ǥ��롣 Lua����Ƭ�� 0x ���դ���������16�����������դ��롣 ͭ���ʿ�����������󤲤��

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

������ ��ʸ����γ��ʤ�ɤ��Ǥ⡢��ĤΥϥ��ե� (--) �ǻϤ�뤳�Ȥ��Ǥ��롣 �⤷ -- ��ľ��˳���Ĺ��̰ʳ��Υƥ����Ȥ�����С����Υ����Ȥ� û�������� �Ǥ��ꡢ�����ޤ�³���� �����Ǥʤ���С������ Ĺ�������� �Ǥ��ꡢ�б������Ĥ�Ĺ��̤ޤ�³���� Ĺ�������Ȥϥ����ɤ���Ū��̵���ˤ��뤿��ˤ褯�Ȥ��롣

2.2 - �ͤȷ�

Lua�� ưŪ�ʷ��θ��� �Ǥ��롣 �Ĥޤꡢ�ѿ��Ϸ�����������ͤ�������ġ� ������ι�ʸ�Ϥʤ��� ���٤Ƥ��ͤϼ�ʬ���ȤǷ����ݻ����Ƥ��롣

Lua�Τ��٤Ƥ��ͤ� �ե������ȥ��饹���� �Ǥ��롣 �Ĥޤꡢ�����ʤ��ͤ��ѿ��˳�Ǽ�Ǥ���¾�δؿ��˰������Ϥ����Ȥ��Ǥ�������ͤȤ����֤����Ȥ��Ǥ��롣

Lua�ˤ�8�Ĥδ��ܷ������롣 nil���֡��ꥢ����������ʸ�������ؿ����桼�����ǡ���������å����ơ��֥� �Ǥ��롣 nil �� nil �ͤη��Ǥ��롣���μ��������¾�Τ����ʤ��ͤȤ�ۤʤ뤳�ȤǤ��ꡢ�̾���Ω���ͤ��ʤ����Ȥ�ɽ���� �֡��ꥢ�� �� false �� true ���ͤ���ķ��Ǥ��롣 nil �� false �϶��˾��Ƚ�Ǥǵ��Ȥʤꡢ¾���ͤϿ��Ȥʤ롣 ���� �ϼ¿� (double) ��ɽ�����롣 (���������ͤ�����ɽ���Ȥ���float��long�ʤ�¾�η���Ȥ��褦Lua���󥿥ץ꥿��ӥ�ɤ�ľ���Τϴ�ñ�Ǥ��롣 �ե����� luaconf.h �򻲾ȡ�) ʸ���� ��ʸ���������ɽ�����롣 Lua��8�ӥåȥ��꡼��Ǥ��ꡢ ʸ����ˤϥ��� (`\0��) ��ޤत���ʤ�8�ӥå�ʸ����ޤळ�Ȥ��Ǥ��� (2.1 �򻲾�)��

Lua��Lua�ǽ񤫤줿�ؿ���C�ǽ񤫤줿�ؿ���Ƥ٤� (2.5.8 �򻲾�)��

�桼�����ǡ��� ��Ǥ�դ�C�Υǡ�����Lua���ѿ��˳�Ǽ���뤿����Ѱդ��줿�� ���η������Υ���֥��å�����������������������Ӥ�����ơ�Lua�Ǥϱ黻���������Ƥ��ʤ��� �������ʤ��顢�᥿�ơ��֥� ���Ѥ��뤳�Ȥǡ� �ץ�����ޤϥ桼�����ǡ������Ф���黻��������뤳�Ȥ��Ǥ��� (2.8 �򻲾�)�� �桼�����ǡ�����Lua��Ǻ�ä����ѹ����뤳�ȤϤǤ�����C��API���̤��ƤΤ߲�ǽ�Ǥ��롣 ����ϴ����˥ۥ��ȥץ������˽�ͭ���줿�ǡ����Ǥ��뤳�Ȥ��ݾڤ��롣

����å� �ϼ¹Ԥ���Ƥ��뤽�줾��Υ���åɤ�ɽ���������롼�����������뤿��˻Ȥ��� (2.11 �򻲾�)�� Lua�Υ���åɤ�OS�Υ���åɤ�Ʊ���ʤ��褦�ˡ� Lua�ϥ���åɤ򥵥ݡ��Ȥ��ʤ������ƥ��Ǥ⥳�롼����򥵥ݡ��Ȥ��롣

�ơ��֥� ��Ϣ������Ǥ��롣 ���ʤ�����ͤ����Ǥʤ�Ǥ�դ��� (nil �����) �򥭡��ˤǤ�������Ǥ��롣 �ơ��֥�� �ۼﺮ�� �Ǥ��롣 �Ĥޤꤢ���뷿���� (nil �����) ����Ĥ��Ȥ��Ǥ��롣 �ơ��֥��Lua��ͣ��Υǡ�����¤�Ǥ��ꡢ ���̤������¾������ɽ�����硢�쥳���ɡ�����ա��ĥ꡼�ʤɤ�ɽ�����뤿��˻Ȥ��롣 �쥳���ɤ�ɽ������Ȥ��ϡ��ե������̾�򥤥�ǥå����Ȥ��ƻȤ��� ���Τ���� a.name �Ȥ���ɽ���� a["name"] �Υ��󥿥å������奬���Ȥ����Ѱդ���Ƥ��롣 �ޤ���Lua�ǥơ��֥���뤿���������ɽ���������Ĥ����� (2.5.7 �򻲾�)��

����ǥå�����Ʊ�͡��ơ��֥�ե�����ɤ��ͤˤ�Ǥ�դη� (nil �����) ���Ǽ�Ǥ��롣 �äˡ��ؿ����ե������ȥ��饹�Ǥ��뤿�ᡢ�ơ��֥�ե�����ɤϴؿ����Ǽ���뤳�Ȥ��Ǥ��롣 ���Τ���ơ��֥�� �᥽�å� ����Ĥ��Ȥ��Ǥ��� (2.5.9 �򻲾�)��

�ơ��֥롢�ؿ�������åɡ��桼�����ǡ������ͤ� ���֥������� �Ǥ��롣 �ѿ��Ϥ����μºݤ��ͤ��������������� ���� ���Ƥ�������Ǥ��롣 �����������Ϥ����ؿ�������ͤϡ�����ͤؤλ��Ȥ򰷤����ͤΥ��ԡ��ϹԤ��ʤ���

�饤�֥��ؿ� type ��Ϳ����줿�ͤη���ɽ��ʸ������֤���

2.2.1 - �Ѵ�

Lua��ʸ����ȿ��ͤ�¹Ի��˼�ưŪ���Ѵ����롣 ���٤Ƥο��ر黻�ϡ�ʸ�����Ŭ�Ѥ����ȡ�����Ū���Ѵ��롼��˴�Ť��Ƥ���ʸ�������ͤ��Ѵ����褦�Ȥ��롣 �դˡ�ʸ���󤬴��Ԥ����Ȥ����ǿ��ͤ��Ȥ��ȡ����ο��ͤϰ���Ū�ʷ�����ʸ������Ѵ�����롣 ���ͤ�ʸ������Ѵ��������ˡ�����˥���ȥ����뤹����ϡ� ʸ����饤�֥��� format �ؿ���Ȥ� (string.format �򻲾�)��

2.3 - �ѿ�

�ѿ����ͤ��Ǽ������Ǥ��롣 Lua�ˤϡ��������Х��ѿ������������ѿ����ơ��֥�ե�����ɤλ�������ѿ������롣

ñȯ��̾���ϥ������Х��ѿ������������ѿ���ɽ�� (�ޤ��ϴؿ��β��������⤷��ʤ���������ϥ��������ѿ��ΰ��Ǥ���)��

	var ::= Name

(2.1 �򻲾�) ���������Ƥ���褦�ˡ�̾���ϼ��̻Ҥ�ɽ����

����Ū�˥���������������ʤ��¤ꡢ�ѿ��ϥ������Х�Ȥߤʤ���� (2.4.7 �򻲾�)�� ���������ѿ��� �쥭�����륹������ ������� ���Υ����������������줿�ؿ����鼫ͳ�˥��������Ǥ��� (2.6 �򻲾�)��

�ǽ���������Ԥ��������ѿ����ͤ� nil �Ǥ��롣

�ơ��֥�򥤥�ǥå����դ����뤿��ˤϳѥ��å���Ȥ���

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

�ǽ�μ� (prefixexp) �ϥơ��֥롢 �����ܤμ� (exp) �ϥơ��֥���Υ���ȥ����ꤹ���ͤǤʤ���Фʤ�ʤ��� �ơ��֥�Υ���ǥå�������ꤹ�뼰�ϸ��ꤵ�줿��ʸ����ġ� �ܺ٤� 2.5 �򻲾ȡ�

��ʸ var.Name �� var["Name"] ��ñ�ʤ륷�󥿥å������奬���Ǥ��ꡢ �ơ��֥�ե�����ɤ򼨤�����˻Ȥ���

	var ::= prefixexp `.�� Name

�������Х��ѿ��ȥơ��֥�ե�����ɤإ�������������̤ϥ᥿�ơ��֥�ˤ�ä��Ѥ����롣 ����ǥå����դ��ѿ� t[i] �ؤΥ��������� gettable_event(t,i) �θƤӽФ��������Ǥ��� (gettable_event �ؿ��δ����������� 2.8 �򻲾ȡ� ���δؿ���Lua�����������Ƥ֤��ȤϤǤ�����ñ�������Τ����Ѥ��Ƥ�������Ǥ���)��

���٤ƤΥ������Х��ѿ��ϡ��Ķ��ơ��֥� �ޤ���ñ�� �Ķ� (2.9 �򻲾�) �ȸƤФ���̾��Lua�Υơ��֥���ˡ��ե�����ɤȤ���¸�ߤ��Ƥ��롣 �ƴؿ��Ϥ��줾���ȼ��˴Ķ��ؤλ��Ȥ������ ���δؿ���ǤΤ��٤ƤΥ������Х��ѿ��ϡ����δĶ��ơ��֥�򻲾Ȥ��롣 �ؿ������줿�Ȥ����ؿ��ϡ����줬���줿�ؿ����鸫����Ķ�������Ѥ��� Lua�δؿ��δĶ��ơ��֥���������ˤ� getfenv ��Ƥ֡� �ѹ�����ˤ� setfenv ��Ƥ֡� (C�δؿ��δĶ��ϥǥХå��饤�֥��ǤΤ����Ǥ��� (5.9 �򻲾�)��)

�������Х��ѿ� x �ؤΥ��������� _env.x �������Ǥ��ꡢ �ʲ��������Ǥ��롣

       gettable_event(_env, "x")

��������_env �ϴؿ����¹Ԥ���Ƥ���Ķ���ɽ�� (gettable_event �ؿ��δ����������� 2.8 �򻲾ȡ� ���δؿ���Lua������������ɤ����Ǥ��ʤ��� Ʊ�ͤ��ѿ� _env ��Lua���������Ƥ��ʤ��� ����Ϥ��������Τ�����Ѥ��Ƥ�������Ǥ���)��

2.4 - ʸ

Lua��Pascal��C��Ʊ���褦�˰���Ū��ʸ�Υ��åȤ򥵥ݡ��Ȥ��Ƥ��롣 ���������湽¤���ؿ��ƤӽФ����ơ��֥륳�󥹥ȥ饯�����ѿ�������ʤɤǤ��롣

2.4.1 - �����

Lua�μ¹Ԥ�ñ�̤� ����� �ȸƤФ�롣 ����󥯤ϡ�ñ��ˡ����֤˼¹Ԥ����ʸ��Ϣ�ʤ�Ǥ��롣 ���줾���ʸ���ˤϾ�ά��ǽ�ʥ��ߥ�������֤��Ƥ��ɤ���

	chunk ::= {stat [`;��]}
��ʸ��¸�ߤ��ʤ����ᡢ`;;�� �ϵ�����Ƥ��ʤ���

Lua�ϥ���󥯤򡢲��ѸĤΰ��������̵̾�ؿ������ΤȤ��ư��äƤ��� (2.5.9 �򻲾�)�� ���äơ�����󥯤ϥ��������ѿ�������Ǥ��������������뤳�Ȥ��Ǥ�������ͤ��֤��롣

����󥯤ϥե������ۥ��ȥץ���������ʸ����Ȥ��Ƴ�Ǽ����Ƥ���Ǥ������� ����󥯤��¹Ԥ����Ȥ����ޤ����ۥޥ����̿��˥���ѥ��뤵�졢���줫�饳��ѥ���Ѥߥ����ɤ����ۥޥ���Υ��󥿥ץ꥿�ˤ�äƼ¹Ԥ���롣

����󥯤ϥХ��ʥ�����Υ���ѥ���Ѥߥ����ɤǤ��äƤ��ɤ��� �ܺ٤� luac �ץ������򻲾ȡ� �������ץ������ȥ���ѥ���Ѥ߷����Ϥɤ�����Ѥ��Ƥ��ɤ��� Lua�ϼ�ưŪ�˥ե���������򸡽Ф���Ŭ�ڤ˿����񤦡�

2.4.2 - �֥��å�

ʸ����ϥ֥��å��Ǥ��롣 ��ʸŪ�ˤϡ��֥��å��ϥ���󥯤���������

	block ::= chunk

�֥��å�������Ū��ñ���ʸ�Ȥ��뤳�Ȥ⤢�롣

	stat ::= do block end

����Ū�ʥ֥��å����ѿ�����������פ򥳥�ȥ����뤹��Τ������Ǥ��롣 ����Ū�ʥ֥��å��Ϥޤ��� ¾�Υ֥��å�������� return ʸ�� break ʸ������뤿��˻Ȥ����Ȥ⤢�롣

2.4.3 - ����

Lua��¿������������Ƥ��롣 �����顢����ʸ�ǤϺ��դ��ѿ��ꥹ�ȡ����դ˼��ꥹ�Ȥ�񤯡� �ɤ���Υꥹ�Ȥ⤽�줾������Ǥ򥫥�ޤǶ��ڤ롣

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

���ˤĤ��Ƥ� 2.5 �ǵ������롣

���������ˡ��ͥꥹ�Ȥ��ѿ��ꥹ�Ȥ�Ĺ����Ĵ�ᤵ��롣 �⤷ɬ�פʿ������ͤ�¿����С�;ʬ���ͤϼΤƤ��롣 �⤷ɬ�פʿ������ͤ����ʤ���С�ɬ�פʤ��� nil ���ɲä���롣 �⤷���ꥹ�ȤκǸ夬�ؿ��ƤӽФ��ʤ顢Ĵ������ˡ����δؿ��Τ��٤Ƥ�����ͤ��ͥꥹ�Ȥ��ɲä���� (�������ƤӽФ��򥫥å��ǰϤä����������2.5 �򻲾�)��

����ʸ�ϡ��ޤ����٤Ƥμ���ɾ���������줫�顢�������Ԥ��롣 �����顢���Υ�����

       i = 3
       i, a[i] = i+1, 20
�ϡ�i ��4��������������� a[i] �� i �� (3��) ɾ������뤿�ᡢ a[3] ��20����������롣 a[4] �ϲ��αƶ���ʤ��� Ʊ�ͤˡ�
       x, y = y, x
�� x �� y ���ͤ�򴹤��롣

�������Х��ѿ��ȥơ��֥�ե�����ɤؤ������θ��̤ϡ��᥿�ơ��֥�ˤ�ä��Ѥ����롣 ����ǥå����դ��ѿ��ؤ����� t[i] = val �� settable_event(t,i,val) �������Ǥ��� (settable_event �ؿ��δ����ʵ��Ҥ� 2.8 �򻲾ȡ� ���δؿ���Lua�����������Ƥ֤��ȤϤǤ����� ���������Τ����Ѥ��Ƥ�������Ǥ���)��

�������Х��ѿ��ؤ����� x = val ������ _env.x = val �������Ǥ��ꡢ �ʲ��������Ǥ��롣

       settable_event(_env, "x", val)

��������_env �ϴؿ����¹Ԥ���Ƥ���Ķ���ɽ�� (�ѿ� _env ��Lua���������Ƥ��ʤ��� ����Ϥ��������Τ�����Ѥ��Ƥ�������Ǥ���)��

2.4.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 ʸ�⤢�롣 �����2�Ĥμ��ब���� (2.4.5 �򻲾�)��

���湽¤�ξ�P��Ǥ�դ��ͤ�Ȥ�롣 false �� nil �϶��˵��Ǥ��롣 nil �� false �ʳ��Τ��٤Ƥ��ͤϿ��ˤʤ� (�äˡ����ͤ�0���ʸ����Ͽ��Ǥ��뤳�Ȥ�����)��

repeat--until �롼�פǤϡ� ��¦�Υ֥��å��� until ������ɤΤȤ����ǤϤʤ���P�θ�˽���롣 �Ĥޤꡢ��P�ϥ롼�ץ֥��å�����¦��������줿���������ѿ��򻲾ȤǤ��롣

return ʸ�ϴؿ������� (����Ϥ����δؿ��Ǥ���) �����ͤ��֤�����˻Ȥ��� �ؿ������󥯤�1�İʾ���ͤ��֤����Ȥ��Ǥ��롣 return ʸ�ι�ʸ�ϰʲ����̤ꡣ

	stat ::= return [explist1]

break ʸ�� while��repeat��for �롼�פμ¹Ԥ�λ���� �롼�פμ��ޤǥ����åפ��롣

	stat ::= break

break �ϺǤ���¦�Υ롼�פ򽪤�餻�롣

return ʸ�� break ʸ�ϥ֥��å��� �Ǹ� ��ʸ�Ȥ��ƤΤ߽񤯤��Ȥ�������롣 return �� break ��֥��å�������ǻȤ����Ȥ�������ɬ�פʤ顢 ����Ū�������֥��å���Ȥ����Τ褦�ʴ��Ѷ��Ȥ����ɤ���

    do return end
    do break end
����� return �� break �� (����) �֥��å��κǸ��ʸ�ˤʤ롣

2.4.5 - forʸ

for ʸ�ˤϡ������Ѥ����Ѥ�2�Ĥη��������롣

������ for �롼�פ������ѿ������������é�äƥ����ɥ֥��å��򷫤��֤��� �ʲ������ι�ʸ�Ǥ��롣

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

block �� name ���ǽ�� exp �ǻϤޤä������ܤ�exp ��ã����ޤǡ� �����ܤ� exp ���Ŀʤ�֡������֤���롣 ������Τˤϡ����Τ褦�� for ʸ

       for var = 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 var = _var
           block
           _var = _var + _step
         end
       end

�ʲ�����������:

���� for ʸ�� ���ƥ졼�� �ȸƤФ��ؿ����̤���Ư���� ���줾��η����֤��ˤĤ��ơ��������ͤ��������뤿��˥��ƥ졼���ؿ����ƤФ졢nil �ˤʤä��Ȥ����ǻߤޤ롣 ���� for �롼�פϰʲ��ι�ʸ�Ǥ��롣

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

���Τ褦�� 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)
           _var = var_1
           if _var == nil then break end
           block
         end
       end

�ʲ�����������:

2.4.6 - ʸ�Ȥ��Ƥδؿ��ƤӽФ�

�����Ѥ�����Ƥ��뤿�ᡢ�ؿ��ƤӽФ���ʸ�Ȥ��Ƽ¹ԤǤ��롣

	stat ::= functioncall

���ξ�硢����ͤϤ��٤ƼΤƤ��롣 �ؿ��ƤӽФ��� 2.5.8 ���������롣

2.4.7 - �����������

���������ѿ��ϥ֥��å�����ɤ��ǤǤ�����Ǥ��롣 ����Ͻ���ͤ�������ȼ�äƤ�褤��

	stat ::= local namelist [`=�� explist1]

�⤷����С�¿��������Ʊ����ʸ�ǽ���ͤ���������� (2.4.3 �򻲾�)�� �����Ǥʤ���С��ѿ��Ϥ��٤� nil �ǽ��������롣

����󥯤�ޤ��֥��å��Ǥ��뤫�� (2.4.1 �򻲾�)�� ����Ū�ʥ֥��å��γ�¦�Υ���󥯤Ǥ���������ѿ�������Ǥ��롣 ���Τ褦�ʥ��������ѿ��Υ������פϥ���󥯤ν����ޤ�³����

���������ѿ��βĻ�롼��� 2.6 ���������롣

2.5 - ��

Lua�δ��ܤμ���ʲ��˼�����

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

���ͤ�ʸ�����ƥ��� 2.1 ������������ �ѿ��� 2.3 ������������ �ؿ������ 2.5.9 ���������롣 �ؿ��ƤӽФ��� 2.5.8 ���������롣 �ơ��֥륳�󥹥ȥ饯���� 2.5.7 ���������롣 3�ĤΥɥåȤ�ɽ�������Ѱ������ϡ����Ѱ����ؿ�����Ǥ����Ȥ��롣 ����� 2.5.9 ���������롣

���黻�Ҥϻ��ѱ黻�� (2.5.1 �򻲾�)�� �ط��黻�� (2.5.2 �򻲾�)�� �����黻�� (2.5.3 �򻲾�) �����롣 ñ��黻�Ҥ�ñ��ޥ��ʥ� (2.5.1 �򻲾�)�� ñ�� not (2.5.3 �򻲾�)�� ������ñ�� Ĺ���黻�� (2.5.5 �򻲾�) �����롣

�ؿ��ƤӽФ��Ȳ��Ѱ�������ʣ�����ͤ��֤��� ����ʸ�Ȥ��ƻȤ�줿��� (2.4.6 �򻲾�) (�ؿ��ƤӽФ����Ф��ƤΤ߲�ǽ)�� ��̤Υꥹ�Ȥϥ����Ĥ�Ĵ�ᤵ�졢�Ĥޤꤹ�٤Ƥ�����ͤ��ΤƤ��롣 ¾�μ������ꥹ�Ȥ�����ǻȤ�줿���ϡ� ��̤Υꥹ�Ȥ�1�Ĥ�Ĵ�ᤵ�졢�Ĥ�Ϥ��٤ƼΤƤ��롣 �����ꥹ�ȤκǸ�����ǤȤ��ƻȤ�줿���ϡ� Ĵ��ϹԤ��ʤ� (���å��ǰϤä��������)��

�����Ĥ����󤲤롣

       f()                -- ����ͤ�0�Ĥ�Ĵ�ᤵ���
       g(f(), x)          -- f()������ͤ�1�Ĥ�Ĵ�ᤵ���
       g(x, f())          -- x�˲ä���f()�Τ��٤Ƥ�����ͤ�g���Ϥ�
       a,b,c = f(), x     -- f()������ͤ�1�Ĥ�Ĵ�ᤵ��� (������c�ˤ�nil������)
       a,b = ...          -- a�˲��Ѱ����κǽ���͡�b��2���ܤ��ͤ�����
                          -- (�б�����������ʤ��ä���硢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�Ĥ�Ĵ�ᤵ���

���å��˰Ϥޤ줿���Ͼ�ˤ���1�Ĥ��ͤ��֤��� �Ĥޤꡢ���Ȥ� f ��ʣ�����ͤ��֤��Ƥ⡢(f(x,y,z)) �Ͼ��ñ����ͤȤʤ롣 (f(x,y,z)) ���ͤϡ�f ���֤��ǽ���ͤǤ��롣 ���뤤�� f �������֤��ʤ���С�nil �Ȥʤ롣

2.5.1 - ���ѱ黻��

Lua�ϰ���Ū�ʻ��ѱ黻�Ҥ򥵥ݡ��Ȥ��Ƥ��롣 + (�û�)�� - (����)��* (�軻)�� / (����)��% (��;)��^ (�߾�)�� �����ñ��� - (���ȿž)�� �⤷���ڥ��ɤ����͡����뤤�Ͽ��ͤ��Ѵ��Ǥ���ʸ���� (2.2.1�򻲾�) �ʤ顢���٤Ƥα黻���̾�ΰ�̣����ġ� �߾��Ǥ�դλؿ����Ф���ư��롣 �㤨�С�x^(-0.5) �� x ��ʿ�����εտ���׻����롣 ��;�ϰʲ��Τ褦���������Ƥ��롣

       a % b == a - math.floor(a/b)*b
�Ĥޤꡢ���̵����˸����äƴݤ��줿��껻��;��Ǥ��롣

2.5.2 - �ط��黻��

Lua�δط��黻�Ҥϰʲ����̤�Ǥ��롣

       ==    ~=    <     >     <=    >=

�����α黻�ҤϾ�� false �� true �����줫�η�̤��֤���

���� (==) �Ϥޤ����ڥ��ɤη�����Ӥ��롣 �⤷�����ۤʤäƤ����顢��̤� false �Ǥ��롣 �����Ǥʤ���С����ڥ��ɤ��ͤ���Ӥ���롣 ���ͤ�ʸ����ϰ���Ū����ˡ����Ӥ��롣 ���֥������� (�ơ��֥롢�桼�����ǡ���������åɡ��ؿ�) �� ���� ����Ӥ��� 2�ĤΥ��֥������Ȥ� Ʊ�� ���֥������ȤǤ�����������������Ȥߤʤ��� ���������֥������� (�ơ��֥롢�桼�����ǡ������ؿ�) ���ä��Ȥ��Ͼ�ˡ� ���ο��������֥������Ȥϡ�������¸�ߤ��Ƥ������֥������ȤȰۤʤ롣

"eq"�᥿�᥽�åɤ�Ȥäơ��ơ��֥��桼�����ǡ�����Lua����Ӥ�����ˡ���Ѥ����� (2.8 �򻲾�)��

2.2.1 ���Ѵ��롼���������Ӥˤ�Ŭ�Ѥ���ʤ��� ���Τ��ᡢ"0"==0 �� false ��ɾ�����졢 t[0] �� t["0"] �ϰۤʤä��ơ��֥륨��ȥ�򼨤���

�黻�� ~= �����Τ����� (==) ������Ǥ��롣

�ط��黻�Ҥϼ��Τ褦��Ư���� ������ξ�����ͤʤ�С�������Ŭ�ڤ���Ӥ���롣 �⤷ξ���ΰ�����ʸ����ʤ�С����ߤΥ�������˽��äƤ����ͤ���Ӥ���롣�����Ǥʤ���С�Lua��"lt"�ޤ���"le"�᥿�᥽�åɤ��ߤ� (2.8 �򻲾�)��

2.5.3 - �����黻��

Lua�������黻�Ҥϼ����̤�Ǥ��롣

       and   or    not

���湽¤ (2.4.4 �򻲾�) ��Ʊ������ ���٤Ƥ������黻�Ҥ� false �� nil ��ξ���򵶡�����ʳ��Τ��٤Ƥ򿿤Ȥߤʤ���

����黻�� not �Ͼ�� false �� true ���֤��� �����ѱ黻�� and �ϡ��ǽ�ΰ����� false �� nil �ʤ餽���ͤ��֤��������Ǥʤ���������ܤΰ������֤��� �����±黻�� or �Ϻǽ�ΰ����� false �� nil �ʳ��ʤ餽���ͤ��֤��������Ǥʤ���������ܤΰ������֤��� 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
(���Υޥ˥奢��Ǥ� `-->�� �Ǽ��η�̤򼨤���)

2.5.4 - Ϣ��

Lua��ʸ����Ϣ��黻�ҤϤդ��ĤΥɥå� (`..��) ��ɽ���� �⤷ξ���Υ��ڥ��ɤ�ʸ���󤫿��ͤʤ顢������ 2.2.1 �ǽҤ٤��롼��˽��ä�ʸ������Ѵ�����롣 �����Ǥʤ���С�"concat"�᥿�᥽�åɤ��ƤФ�� (2.8 �򻲾�)��

2.5.5 - Ĺ���黻��

Ĺ���黻�Ҥ�ñ��黻�� # ��ɽ����롣 ʸ�����Ĺ���Ϥ��ΥХ��ȿ��Ǥ��� (�Ĥޤꡢ��ʸ����1�Х��Ȥ��Ȥ������Ρ�ʸ�����Ĺ���Ǥ���)��

�ơ��֥� t ��Ĺ���ϡ� t[n] �� nil �Ǥʤ� t[n+1] �� nil �Ǥ���褦������ n ���������Ƥ��롣 �ޤ���t[1] �� nil �ʤ� n �ϥ����ˤʤꤦ�롣 nil �Ǥʤ��ͤ�1���� n �ޤdz�Ǽ����Ƥ������̤�����Ǥϡ� ����Ĺ���ϺǸ�Υ���ǥå��� n ���������֤��� ����ˡַ�פ������� (�Ĥޤ�֤� nil ��������)�� #t �Ϥɤ줫�� nil �ΤҤȤ������֤����⤷��ʤ� (�Ĥޤꡢ���� nil ������ν����Ǥ���褦�˸�����Τ�)��

2.5.6 - ͥ����

Lua�Ǥα黻�Ҥ�ͥ���̤�ʲ���ɽ�˼����� ͥ���̤��㤤��������

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

�����̤�ˡ����å���ȤäƼ���ͥ���̤��Ѥ��뤳�Ȥ��Ǥ��롣 Ϣ�� (`..��) ���߾� (`^��) �ϱ����Ǥ��롣 ¾�����黻�ҤϤ��٤ƺ����Ǥ��롣

2.5.7 - �ơ��֥륳�󥹥ȥ饯��

�ơ��֥륳�󥹥ȥ饯���ϥơ��֥���뼰�Ǥ��롣 ���󥹥ȥ饯����ɾ������뤿�Ӥ˿������ơ��֥뤬����롣 ���Υơ��֥���뤳�Ȥ⡢�����Ĥ��Υե�����ɤ˽���ͤ���ä��ơ��֥���뤳�Ȥ�Ǥ��롣 ���󥹥ȥ饯���ι�ʸ�ϰʲ����̤�Ǥ��롣

	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"         -- �ǽ��exp
         t[2] = "y"         -- 2���ܤ�exp
         t.x = 1            -- temp["x"] = 1
         t[3] = f(x)        -- 3���ܤ�exp
         t[30] = 23
         t[4] = 45          -- 4���ܤ�exp
         a = t
       end

�⤷�Ǹ�Υե�����ɤ� exp �����ǡ����μ����ؿ��ƤӽФ������Ѱ������Ǥ���С� ��������ͤ����٤ƥꥹ�Ȥ��ɲä���� (2.5.8 �򻲾�)�� ������򤱤�ˤϡ��ؿ��ƤӽФ�(���뤤�ϲ��Ѱ�����)�򥫥å��ǰϤ� (2.5 �򻲾�)��

��ư���������ɤ������ʤ褦�ˡ��ƥե�����ɤν����˾�ά��ǽ�ʥ��ߥ�������դ��Ƥ��ɤ���

2.5.8 - �ؿ��ƤӽФ�

Lua�δؿ��ƤӽФ��ϰʲ��ι�ʸ�Ǥ��롣

	functioncall ::= prefixexp args

�ؿ��ƤӽФ��Ǥϡ� �ޤ� prefixexp �� args ��ɾ������롣 �⤷ prefixexp ���ͤ� �ؿ� �Ǥ���С�Ϳ����줿�����Ǥ��δؿ����ƤФ�롣 �����Ǥʤ���С�prefixexp �� "call" �᥿�᥽�åɤ��ƤФ�롣 ���ΤȤ� prefixexp ���ǽ�ΰ����Ȥ����Ϥ��졢�����ܰʹߤ˸����ΰ�����³�� (2.8 �򻲾�)��

��

	functioncall ::= prefixexp `:�� Name args
�ϡ֥᥽�åɡפȸƤФ�롣 �ƤӽФ� v:name(...) �� v.name(v, ...) �Υ��󥿥å������奬���Ǥ��ꡢ v ��ɾ�����������٤Ǥ������������ۤʤ롣

�����ϰʲ��ι�ʸ����ġ�

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

�����Τ��٤Ƥμ��ϸƤӽФ�����ɾ������롣 f{...} �� f({...}) �Υ��󥿥å������奬���Ǥ��ꡢ�������ơ��֥�ҤȤĤ������Ȥʤ롣 f'...' (����� f"..." �� f[[...]]) �� f('...') �Υ��󥿥å������奬���Ǥ��ꡢ������ʸ�����ƥ��ҤȤĤǤ��롣

Lua�Υե꡼�ե����ޥåȹ�ʸ���㳰�Ȥ��ơ� �ؿ��ƤӽФ��� `(�� ��ľ���Dz��Ԥ��뤳�ȤϤǤ��ʤ��� �������¤ˤ�äƸ����ۣ�椵���򤱤��롣 �Ĥޤꡢ�������¤��ʤ��ä���硢�⤷���Τ褦�˽񤯤�

       a = f
       (g).x(a)

Lua��ñ��μ� a = f(g).x(a) �Ȳ�ᤷ�����⤷��ʤ��� ���ξ�硢2�Ĥ�ʸ�ˤ�������д֤˥��ߥ�����ɬ�פǤ��롣 �����ºݤˤϡ�f ��ƤӤ������ (g) �����β��Ԥ�������ʤ���Фʤ�ʤ���

return functioncall �Τ褦�ʸƤӽФ������� ��ü�ƤӽФ� �ȸƤФ�롣 Lua�� ��ü�ƤӽФ���Ŭ�� (�ޤ��� ��ü�Ƶ���Ŭ��) ��������Ƥ��롣 ��ü�ƤӽФ��Ǥϡ��ƤӽФ��줿�ؿ��ϸƤӽФ�¦�ؿ��Υ����å�����ȥ������Ѥ��롣 ���η�̡���ü�ƤӽФ��Υͥ��ȿ������¤ʤ��� (̵�¤˺Ƶ��ƤӽФ�����) �ץ�������¹ԤǤ��롣 �������ʤ��顢��ü�ƤӽФ��ϸƤӽФ�¦�ؿ��˴ؤ���ǥХå������ä��Ƥ��ޤ��� ��ü�ƤӽФ��ϡ�ñ��δؿ��ƤӽФ��� return ����Ȥ������̤ʾ����ǤΤߵ����뤳�Ȥ����ա� ���ι�ʸ�Ǥϡ��ƤӽФ����ؿ�������ͤ����Τޤ޸ƤӽФ�¦�ؿ�������ͤˤʤ롣 ��äơ��ʲ�����Ϥɤ�⽪ü�ƤӽФ��ǤϤʤ���

       return (f(x))        -- ����ͤ�1�Ĥ�Ĵ�ᤵ��Ƥ���
       return 2 * f(x)      -- ����ͤ��ù�����Ƥ���
       return x, f(x)       -- ����ͤ��ɲä���Ƥ���
       f(x); return         -- ����ͤ��ΤƤ��Ƥ���
       return x or f(x)     -- ����ͤ�1�Ĥ�Ĵ�ᤵ��Ƥ���

2.5.9 - �ؿ����

�ؿ�����ι�ʸ��ʲ��˼�����

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

�ʲ��Υ��󥿥å������奬���ϴؿ������ñ�㲽���롣

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

�ʲ���ʸ

       function f () ... end
�ϼ��Τ褦���Ѵ�����롣
       f = function () ... end

�ʲ���ʸ

       function t.a.b.c.f () ... end
�ϼ��Τ褦���Ѵ�����롣
       t.a.b.c.f = function () ... end

�ʲ���ʸ

       local function f () ... end
�ϼ��Τ褦���Ѵ�����롣
       local f; f = function () ... end
���Τ褦�ˤǤϤʤ���
       local f = function () ... end
(���ΰ㤤�ϡ��ؿ������ f �򻲾ȤǤ��뤫�ɤ����Ǥ��롣)

�ؿ�����ϼ¹Բ�ǽ�ʼ��Ǥ��ꡢ�ؿ� �����ͤ���ġ� Lua������󥯤򥳥�ѥ��뤹��ȡ� ������ˤ���ؿ������Τ⥳��ѥ��뤵��롣 �����ơ�Lua���ؿ������¹Ԥ����Ȥ��� �ؿ��� ���󥹥��󥹲� (�ޤ��� ��������) ����롣 ���δؿ����󥹥��� (�ޤ��� ����������) �ϼ��κǽ�Ū���ͤǤ��롣 Ʊ���ؿ��ΰۤʤ륤�󥹥��󥹤ϰۤʤ���������ѿ��Ȱۤʤ�Ķ��ơ��֥�򻲾Ȥ����礬���롣

�������ϥ��������ѿ��Ȥ��ƿ����񤤡��Ϥ��줿�°������ͤǽ��������롣

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

�ؿ����ƤФ��ȡ��°����ꥹ�Ȥϲ������ꥹ�Ȥ�Ĺ����Ĵ�ᤵ��롣 ���������������ꥹ�ȤκǸ夬3�ĤΥɥå� (`...��) �Ǥ��� ���Ѱ��� �ξ�������� ���Ѱ����Ǥϼ°�����Ĵ�ᤵ�줺�� �����;ʬ�μ°����Ϥ��٤� ���Ѱ����� �ˤ�äƴؿ����Ϥ���롣 ���Ѱ�������ޤ�3�ĤΥɥåȤǽ񤯡� ���μ����ͤϡ����٤Ƥ�;ʬ�μ°�������ʤ�ꥹ�ȤǤ��롣 �����ʣ��������ͤ���Ĵؿ��˻��Ƥ��롣 ���Ѱ�������¾�μ������ꥹ�Ȥ�����ǻȤ�줿���ϡ� ��̤Υꥹ�Ȥ����Ǥ�1�Ĥ�Ĵ�ᤵ��롣 �ꥹ�ȤκǸ�����ǤǻȤ�줿���ϡ� Ĵ��ϹԤ��ʤ�(���å��ǰϤä��������)��

��Ȥ��ơ��ʲ��������ͤ��롣

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

���ξ�硢�°������鲾�����Ȳ��Ѱ������ذʲ��Τ褦�˥ޥåԥ󥰤���롣

       �ƤӽФ�         ������

       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, ... -->  (�ʤ�)
       g(3, 4)          a=3, b=4,   ... -->  (�ʤ�)
       g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8
       g(5, r())        a=5, b=1,   ... -->  2  3

�ؿ��η�̤��֤��ˤ� return ʸ��Ȥ� (2.4.4 �򻲾�)�� return ʸ�˽в�鷺�����椬�ؿ��ν����ޤ�ã�����顢�ؿ��ϲ����֤��ʤ���

������ ��ʸ��Ȥä� �᥽�å� ������Ǥ��롣 �᥽�åɤȤϡ����ۤΰ��� self ��;ʬ�˻��Ĵؿ��Ǥ��롣 �Ĥޤꡢ�ʲ��ι�ʸ

       function t.a.b.c:f (...) ... end
�ϡ��ʲ���ʸ�Υ��󥿥å������奬���Ǥ��롣
       t.a.b.c.f = function (self, ...) ... end

2.6 - �Ļ�롼��

Lua�ϥ쥭�����륹�����פ���ĸ���Ǥ��롣 �ѿ��Υ������פϡ����줬������줿ʸ�� �� ����Ϥޤꡢ ���������ޤ�Ǥ���¦�Υ֥��å���end�ǽ���롣 �ʲ������ͤ��褦��

  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 �ϳ�¦���ѿ��򻲾Ȥ��롣

�쥭�����륹�����פΥ롼��ˤ�ꡢ ���������ѿ��Ϥ��Υ������פ���¦��������줿�ؿ����鼫ͳ�˥��������Ǥ��롣 �����ؿ�����Ȥ�����������ѿ��ϡ� �����ؿ�����Ǥ� ����� �ޤ��� �������������ѿ� �ȸƤФ�롣

local ʸ��¹Ԥ��뤿�Ӥ˿��������������ѿ����������뤳�Ȥ����ա� �ʲ������ͤ��衣

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

���Υ롼�פ�10�ĤΥ��������� (�Ĥޤ�ƿ̾�ؿ���10�ĤΥ��󥹥���) ���롣 ����������Ϥ��٤�Ʊ�� x ��ͭ���뤬�� ���줾��ۤʤä� y ����ġ�

2.7 - ���顼����

Lua���Ȥ߹��߳�ĥ����Ǥ��뤫�顢 ���٤Ƥ�Lua���������ϥۥ��ȥץ�������C�Υ����ɤ�Lua�饤�֥��δؿ���Ƥ֤��Ȥˤ�äƥ������Ȥ��� (lua_pcall �򻲾�)�� Lua�Υ���ѥ������¹���ǥ��顼���������Ȥ��ϡ����椬C���֤��졢 Ŭ�ڤ�ư���Ԥ����Ȥ��Ǥ��� (�㤨�Х��顼��å�������Ф��Ȥ�)��

Lua�����ɤ� error �ؿ���Ƥ֤��Ȥ�����Ū�˥��顼�򵯤������Ȥ��Ǥ��롣 �⤷Lua��ǥ��顼����館��ɬ�פ�����С� pcall �ؿ���Ȥ��Ф褤��

2.8 - �᥿�ơ��֥�

Lua�Τɤ��ͤ� �᥿�ơ��֥� ����Ĥ��Ȥ��Ǥ��롣 �᥿�ơ��֥� ��Lua���̾�Υơ��֥�Ǥ��뤬�� �����ͤ��Ф����ü�ʱ黻�򤷤��Ȥ��ε�ư��������롣 �᥿�ơ��֥�Υե�����ɤ����ꤹ�뤳�Ȥǡ����֥������Ȥ�ư��򤤤��Ĥ����̤��Ѥ��뤳�Ȥ��Ǥ��롣 �㤨�С����Ͱʳ����ͤ��û��Υ��ڥ��ɤˤʤä��Ȥ��� Lua�ϥ᥿�ơ��֥�� "__add" �ե�����ɤ�����å����롣 �⤷���줬���Ĥ���С��û���Ԥ�����ˤ��δؿ����ƤФ�롣

�᥿�ơ��֥�Υ����� ���٥�����ͤ� �᥿�᥽�å� �ȸƤ֡� ������Ǥ����ȡ�"add" �����٥�Ȥǡ��û���Ԥ��ؿ����᥿�᥽�åɤǤ��롣

getmetatable �ؿ���Ǥ�դ��ͤΥ᥿�ơ��֥����Ф����Ȥ��Ǥ��롣

�ơ��֥�Υ᥿�ơ��֥�� setmetatable �ؿ����ѹ��Ǥ��롣 ¾�η��Υ᥿�ơ��֥��Lua���Ѥ��뤳�ȤϤǤ��ʤ� (�ǥХå��饤�֥������)�� ���Τ���ˤ�C��API��Ȥ�ʤ���Фʤ�ʤ���

�ơ��֥�ȥ桼�����ǡ�������Ω�����᥿�ơ��֥����Ĥ��Ȥ��Ǥ��� (ʣ���Υơ��֥��桼�����ǡ�����Ʊ���᥿�ơ��֥��ͭ���뤳�Ȥ�Ǥ���)�� ¾�η����ͤϡ������Ȥ�ñ��Υ᥿�ơ��֥��ͭ���롣 �Ĥޤꤹ�٤Ƥο��ͤ��Ф��ƤҤȤĤ����᥿�ơ��֥뤬¸�ߤ��� ���٤Ƥ�ʸ������Ф��ƤҤȤĤ����᥿�ơ��֥뤬¸�ߤ��� �ʲ�Ʊ�ͤǤ��롣

�᥿�ơ��֥�ϡ����ѱ黻���ط���ӡ�Ϣ�롢Ĺ���黻�ҡ�����ǥå����դ��ˤĤ��ơ����֥������Ȥ��ɤ������񤦤������椹�롣 �ޤ����桼�������֥������Ȥ˴ؤ��Ƥϡ����֥������Ȥ����١������쥯�Ȥ��줿�Ȥ��˸ƤФ��ؿ�������Ǥ��롣 �Ʊ黻�ˤ� ���٥�� �ȸƤФ���ü�ʥ�������Ϣ�դ����Ƥ��롣 Lua���ͤ��Ф��Ƥ����α黻��Ԥ��Ȥ��� �����ͤ��᥿�ơ��֥����äƤ��ƥ��٥�Ȥ����ꤵ��Ƥ��뤫�����å�����롣 �����˳�����Ƥ�줿�� (�᥿�᥽�å�) ��Lua�����α黻��ɤ��Ԥ����򥳥�ȥ����뤹�롣

�᥿�ơ��֥뤬����ȥ�����Ǥ���黻��ʲ��˼����� �Ʊ黻�ϴ�Ϣ�դ���줿̾���Ƕ��̤���롣 �Ʊ黻�Υ����ϡ�����̾��������2�ĤΥ������������ `__�� ���դ�ʸ����Ǥ��롣 �㤨�С�"add"�黻�Υ����ϡ�ʸ���� "__add" �Ǥ��롣 �����α黻�θ��̤ϡ������˱黻���¹Ԥ���뤫�򵭽Ҥ���Lua�δؿ����������롣

������Lua�Υ����ɤ򼨤��Ƥ���Τϡ�ñ�������Τ���Ǥ��롣 �ºݤϥ��󥿥ץ꥿�˥ϡ��ɥ����ɤ���Ƥ��ꡢ���ε��������ɤ����ΨŪ��ư��롣 �����ǻȤ��Ƥ���ؿ� (rawget��tonumber �ʤ�) �� 5.1 �˵��Ҥ���Ƥ��롣 Ϳ����줿���֥������ȤΥ᥿�᥽�åɤ���Ф������ɤȤ��ơ��ʲ���ɽ�����Ѥ��Ƥ��뤬��

  metatable(obj)[event]
����ϼ��Τ褦���ɤ�Ǥ�餤������
  rawget(metatable(obj) or {}, event)

�Ĥޤꡢ�᥿�᥽�åɤؤΥ���������¾�Υ᥿�᥽�åɤ�ƤӽФ����ȤϤʤ��� ���֥������Ȥ��᥿�᥽�åɤ���äƤ��ʤ��Ƥ⥨�顼�򵯤������ȤϤʤ� (���ξ���ñ�� nil ���֤�)��

2.9 - �Ķ�

����åɡ��ؿ����桼�����ǡ������Υ��֥������Ȥϡ� �᥿�ơ��֥�˲ä��Ƥ⤦�ҤȤġ� ��Ϣ�դ����줿�ơ��֥����ġ� ����� �Ķ� �ȸƤ֡� �᥿�ơ��֥�Ʊ�͡��Ķ������̤Υơ��֥�Ǥ��롣

�桼�����ǡ����˴�Ϣ�դ���줿�Ķ���Lua�ˤȤäƤϰ�̣������ʤ��� ����ϥץ�����ޤΤ���ˡ� �桼�����ǡ����˥ơ��֥���Ϣ�դ��뵡ǽ�Ȥ���¸�ߤ�������Ǥ��롣

����åɤ˴�Ϣ�դ���줿�Ķ��� �������Х�Ķ� �ȸƤ֡� ����ϡ�����åɤȡ�����åɤ��������� (loadfile��loadstring �ޤ��� load ��Ȥä�) �ͥ��Ȥ���Ƥ��ʤ��ؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ�졢 C�Υ����ɤ�ľ�ܥ��������Ǥ��� (3.3 �򻲾�)��

C�δؿ��˴�Ϣ�դ���줿�Ķ���C�Υ����ɤ�ľ�ܥ��������Ǥ��� (3.3 �򻲾�)�� �ޤ����δؿ��Ǻ�������¾��C�δؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ��롣

Lua�δؿ��˴�Ϣ�դ���줿�Ķ��ϡ� ���δؿ�����ǥ����������륰�����Х��ѿ����褹�뤿��˻Ȥ��� (2.3 �򻲾�)�� �ޤ����δؿ��Ǻ�������¾��Lua�δؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ��롣

setfenv ��Ƥ֤�������Υ���åɤ� Lua �δؿ��δĶ����ѹ��Ǥ��롣 getfenv ��Ƥ֤�������Υ���åɤ� Lua �δؿ��δĶ�������Ǥ��롣 ¾�Υ��֥������� (�桼�����ǡ�����C�δؿ���¾�Υ���å�) �δĶ�������ˤϡ�C��API��Ȥ�ʤ���Фʤ�ʤ���

2.10 - ���١������쥯�����

Lua�ϼ�ưŪ�˥����������롣 �Ĥޤꡢ���������֥������ȤΤ���Υ�����ݤ䡢���֥������Ȥ��פ�ʤ��ʤä��Ȥ��β����ˤĤ��ơ�Ǻ�ޤʤ��Ƥ褤�� Lua�ϻ������֥������� (�⤦���������Ǥ��ʤ��ʤä����֥�������) �������� ���١������쥯�� ������¹Ԥ��뤳�Ȥǡ���ưŪ�˥����������롣 �ơ��֥롢�桼�����ǡ������ؿ�������åɡ�ʸ����Ȥ��ä����٤Ƥ�Lua���֥������Ȥϼ�ư�������оݤǤ��롣

Lua�ϥ��󥯥��󥿥�ޡ�������ɥ������ץ��쥯����������Ƥ��롣 ���١������쥯�����μ��������椹�뤿���2�Ĥο��͡� ���١������쥯������� �� ���١������쥯�����ƥå׷��� ��Ȥ����Ȥ��Ǥ��롣

���١������쥯������ͤϡ� �ɤ�����Фä��鿷������������򳫻Ϥ��뤫�����椹�롣 �ͤ��礭���ۤɥ��쥯�����ö�Ū�ˤʤ롣 1��꾮�����ͤˤ���ȡ����쥯���������˿�������������򳫻Ϥ��롣 2�ˤ���ȡ��Ȥ��Ƥ������ι�פ�2�ܤˤʤä��饳�쥯������������������򳫻Ϥ��롣

���ƥå׷����ϡ�������ݤ��Ф��륳�쥯��������®�٤����椹�롣 �ͤ��礭���ۤɥ��쥯�����Ѷ�Ū�ˤʤ뤬�� �ƥ��󥯥��󥿥륹�ƥåפΥ��������礭���ʤ롣 1��꾮�����ͤˤ���ȡ����쥯���������٤��ʤꡢ��̤Ȥ��ƥ������뤬�����ʤ����⤷��ʤ��� �ǥե���Ȥ�2�Ǥϡ�������ݤΡ�2�ܡפ�®�٤ǥ��쥯����ư��롣

C�� lua_gc �� Lua�� collectgarbage ��Ƥ֤ȡ��������ͤ��ѹ��Ǥ��롣 �������ѡ�������ͤǰ������� (���ä� 100 ���Ϥ��� 1.00 ���̣����)�� �����δؿ��ǥ��쥯����ľ������Ǥ��� (��ߤ�������Ƴ���������)��

2.10.1 - ���١������쥯�����᥿�᥽�å�

C��API��Ȥ���硢�桼�����ǡ����˥��١������쥯���᥿�᥽�åɤ�����Ǥ��� (2.8�򻲾�)�� ���Υ᥿�᥽�åɤ� �ե����ʥ饤�� �ȸƤФ�뤳�Ȥ⤢�롣 �ե����ʥ饤����Lua�Υ��١������쥯�������꥽�����ȶ��˻Ȥ���褦�ˤ��� (�ե������ͥåȥ����³���ǡ����١�����³�ʤɤ��Ĥ����ꡢ�ȼ��˳��ݤ���������������Ȥ�)��

�᥿�ơ��֥�� __gc �ե�����ɤ���ĥ桼�����ǡ��������١����ˤʤäƤ⡢���١������쥯���Ϥ���򤹤��ˤϲ�����ʤ��� �������ꡢLua�Ϥ����ꥹ�Ȥ�����롣 ¾�Υ��֥������Ȥβ��������ä����ȡ�Lua�ϥꥹ����Υ桼�����ǡ������Ф��ưʲ��δؿ���Ʊ���Τ��Ȥ�Ԥ���

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

�ƥ��١������쥯����󥵥�����ν����ˡ� ���줿�Ȥ��� �դν��֤� �桼�����ǡ����Υե����ʥ饤�����ƤФ�롣 �Ĥޤꡢ�ǽ�˸ƤФ��ե����ʥ饤���ϡ����ֺǶ�˺��줿�桼�����ǡ����Τ�ΤǤ��롣

2.10.2 - �廲�ȥơ��֥�

�廲�ȥơ��֥� �� �廲�� �����Ǥ���ĥơ��֥�Ǥ��롣 �廲�Ȥϥ��١������쥯����̵�뤵��롣 ����������ȡ����֥������Ȥؤλ��Ȥ��廲�ȤΤߤǤ���С����١������쥯���Ϥ��Υ��֥������Ȥ������Ƥ��ޤ���

�廲�ȥơ��֥�ϡ��������͡����뤤�Ϥ���ξ�����廲�ȤǤ��롣 �廲�ȥ�������ĥơ��֥�ϡ������ϲ������뤬�������ͤϲ������ʤ��� �廲�ȥ����ȼ廲���ͤ�ξ������ĥơ��֥�Ǥϡ��������ͤ������оݤˤʤ롣 �������ͤΤɤ��餫��������������ȡ��������ͤΥڥ����Τ��ơ��֥뤫������롣 �ơ��֥�μ廲�Ȥ������ϡ��᥿�ơ��֥�� __mode �ե�����ɤ�����Ǥ��롣 �⤷ __mode �ե�����ɤ�ʸ����ǡ�ʸ�� `k�� ���ޤޤ�Ƥ����顢�ơ��֥�Υ������廲�ȤȤʤ롣 �⤷ __mode �ե�����ɤ�ʸ�� `v�� ��ޤ�Ǥ����顢�ơ��֥���ͤ��廲�ȤȤʤ롣

�᥿�ơ��֥�Ȥ��ƻȤä���ˡ����Υơ��֥�� __mode �ե�����ɤ��ͤ��ѹ�����٤��ǤϤʤ��� ���Υ᥿�ơ��֥�����椵��Ƥ���ơ��֥�μ廲�Ȥε�ư��̤����Ȥʤ롣

2.11 - ���롼����

Lua�ϥ��롼����򥵥ݡ��Ȥ��Ƥ��롣 ��ĴŪ�ޥ������å� �ȸƤФ�뤳�Ȥ⤢�롣 Lua�Υ��롼�������Ω�˼¹Ԥ���륹��åɤ�ɽ�����Ƥ��롣 �ޥ������åɥ����ƥ�Υ���åɤȤϰ�äơ� ���롼�����yield�ؿ���Ƥ������Ū�˼¹Ԥ����Ǥ��ʤ���Фʤ�ʤ���

���롼�������ˤ� coroutine.create ��Ƥ֡� ����ϤҤȤĤ���������Ȥꡢ����˥��롼����Υᥤ��ؿ����Ϥ��� create �ؿ��Ͽ��������롼���������������� ����å� ���֥������Ȥ��֤��� ���롼����Ϥ����ˤϼ¹Ԥ���ʤ���

coroutine.create �����֤��줿����åɤ�ǽ�ΰ������Ϥ��ƺǽ�� coroutine.resume ��Ƥ���Ȥ��� ���Υᥤ��ؿ��κǽ�ιԤ��饳�롼����μ¹Ԥ��Ϥޤ롣 coroutine.resume ��;ʬ�ΰ�������ꤹ��ȡ������ϥ��롼����Υᥤ��ؿ����Ϥ���롣 ���롼���󤬳��Ϥ��줿�顢������ã���뤫 yield ��Ƥ֤ޤǼ¹Ԥ���롣

���롼�����2�Ĥ���ˡ�Ǽ¹Ԥ򽪤��롣 �ᥤ��ؿ�����return���� (����Ū�ˤ����Ǹ��̿�᤬����äư���Ū�ˤ�) ���ェλ�����Ȥ��ȡ� �ݸ��ʤ����顼�������ư۾ェλ�����Ȥ��Ǥ��롣 �ǽ�ξ��Ǥϡ�true �ȡ��ᥤ��ؿ����������ͤ�coroutine.resume ���֤��� ���顼�ξ��ϡ�coroutine.resume �� false �ȥ��顼��å��������֤���

���롼����� coroutine.yield ��Ƥ֤��Ȥ����Ǥ���롣 ���롼�������Ǥ����ȡ��б����� coroutine.resume ���餹������롣 ���롼�������ǸƤФ줿�ؿ���������Ǥ���Ƥ�Ʊ�ͤǤ��� (�Ĥޤꡢ�ᥤ��ؿ�����ľ��Ū/����Ū�˸ƤФ줿���ᥤ��ؿ��ʳ��δؿ�����Ǥ�)�� ���ξ��⡢coroutine.resume �� true ���֤��� coroutine.yield �˰������Ϥ���Ƥ���С�������֤���롣 ����Ʊ�����롼�����resume����ȡ����Ǥ�����꤫��¹Ԥ��Ƴ�����롣 coroutine.resume ��;ʬ�ʰ������Ϥ��ȡ�coroutine.yield ���餽��餬�֤���롣

coroutine.wrap �ؿ��� coroutine.create ��Ʊ�ͤ˥��롼�����������뤬�� ���롼���󼫿Ȥ��֤��ΤǤϤʤ������롼�����resume����ؿ����֤��� ���δؿ����Ϥ��줿������ coroutine.resume ���ɲäΰ����Ȥ����Ϥ���롣 coroutine.resume ���������ͤϡ��ǽ�ΤҤȤ� (�֡��ꥢ�󷿤Υ��顼������) ��������Ĥ꤬�֤���롣 coroutine.resume �Ȱ�äơ� ���δؿ��ϥ��顼����館�뤳�ȤϤʤ��������ǵ��������顼�ϸƤӽФ���¦�����¤��롣

��Ȥ��ơ����Υ����ɤ�ͤ��롣

function foo (a)
  print("foo", a)
  return coroutine.yield(2*a)
end

co = coroutine.create(function (a,b)
      print("co-body", a, b)
      local r = foo(a+1)
      print("co-body", r)
      local r, s = coroutine.yield(a+b, a-b)
      print("co-body", r, s)
      return b, "end"
end)
       
print("main", coroutine.resume(co, 1, 10))
print("main", coroutine.resume(co, "r"))
print("main", coroutine.resume(co, "x", "y"))
print("main", coroutine.resume(co, "x", "y"))
�����¹Ԥ���ȡ��ʲ��ν��Ϥ����롣
co-body 1       10
foo     2
main    true    4
co-body r
main    true    11      -9
co-body x       y
main    true    10      end
main    false   cannot resume dead coroutine

3 - ���ץꥱ�������ץ�����।�󥿥ե�����

���Υ��������Ǥ�Lua�Τ����C��API���������롣 ����ϡ��ۥ��ȥץ�����बLua��Ư�������뤿���C�δؿ��Υ��åȤǤ��롣 ���٤Ƥ�API�ؿ��ȡ���Ϣ���뷿������ϡ��إå����ե����� lua.h ���������Ƥ��롣

���Υޥ˥奢��Ǥϡִؿ��פȤ������դ�Ȥ���������˥ޥ����Ȥ����󶡤���Ƥ����Τ⤢�롣 ���Τ褦�ʥޥ����Ϥ��٤ơ��ư��������礦�ɰ��٤���ɾ�����졢�����ʤ뱣�줿�����Ѥ�ȯ�����ʤ� (�������ǽ�ΰ���������������ˤϾ��Lua���ơ��Ȥ��Ϥ�)��

�ۤȤ�ɤ�C�Υ饤�֥���Ʊ�ͤˡ� Lua��API�ؿ��ϰ�����������������������å����ʤ��� ���������ե����� luaconf.h ����Υޥ��� luai_apicheck ��Ŭ�ڤ��������Lua��ƥ���ѥ��뤹��ȡ�����ư����ѹ��Ǥ��롣

3.1 - �����å�

Lua��C�Ȥδ֤��ͤ�����Ϥ����뤿��� ���ۥ����å� ��Ȥ��� �����å���γ����Ǥϡ�Lua���� (nil�����͡�ʸ����ʤ�) ��ɽ���Ƥ��롣

Lua��C��Ƥ֤Ȥ��ϡ������Υ����å��ξ��֤�ޤ������ƥ��֤�C�δؿ����ȤäƤ��륹���å��˱ƶ�����ʤ��褦�ˡ������������å����Ѱդ��롣 ���Υ����å���C�δؿ����Ϥ��줿��������Ǽ����Ƥ��ꡢ C�δؿ�����ƤӽФ�¦���֤�����ͤ��Ǽ���뤿��ˤ�Ȥ��� (lua_CFunction �򻲾�)��

�������Τ��ᡢ�ۤȤ�ɤ��䤤��碌��API�ؿ��ϸ�̩�ʥ����å��ε�§�˽��äƤ��ʤ��� ����ˡ�����ǥå��� ��Ȥäơ������å����Ǥ�դ����Ǥ˥��������Ǥ��롣 �ץ饹�Υ���ǥå����ϥ����å���� ���� ���֤�ɽ�� (1 ����Ϥޤ�)�� �ޥ��ʥ��Υ���ǥå����ϥ����å��ȥåפ�������� ���ե��å� ��ɽ���� ����Ū�˸����ȡ������å��� n �Ĥ����Ǥ�����Ȥ��ơ� ����ǥå���1�Ϻǽ������ (�Ĥޤꡢ���Υ����å��˺ǽ���Ѥޤ줿����) ��ɽ���� ����ǥå��� n �ϺǸ�����Ǥ�ɽ���� ����ǥå���-1��Ǹ������ (�Ĥޤꥹ���å��ȥåפˤ�������) ��ɽ���� ����ǥå��� -n �Ϻǽ�����Ǥ�ɽ���� ͭ���� ����ǥå�����1���饹���å��ȥåפδ֤����Ǥ��� (�Ĥޤ� 1 <= abs(index) <= top)��

3.2 - �����������

Lua��API��Ȥ��Ȥ��ϡ���������ݾڤ�����Ǥ�����롣 �äˡ������å������С��ե����˵����դ��ʤ���Фʤ�ʤ��� �����å��������򿭤Ф�����ˤϴؿ� lua_checkstack ��Ȥ���

Lua��C��Ƥ֤Ȥ��ϡ� ����Ǥ����Τ� LUA_MINSTACK �ĤΥ����å����Ǥ����Ѳ�ǽ�Ǥ��롣 LUA_MINSTACK ��20���������Ƥ��ꡢ �����å��ˤɤ�ɤ����Ǥ��Ѥ�褦�ʥ롼�פ����ä��ꤷ�ʤ���С� ���̤ϥ����å����֤򵤤ˤ��ʤ��Ƥ��ɤ���

¿�����䤤��碌�ؿ��ˤϡ������å�����������Ѳ�ǽ��Ǥ�դΥ���ǥå����ͤ�Ȥ��롣 �Ĥޤꡢlua_checkstack ��Ȥä�����Ǥ�����祹���å���Ĺ���ޤǤΥ���ǥå����Ǥ��롣 ���Τ褦�ʥ���ǥå����� ���������ǽ�ʥ���ǥå��� �ȸƤ֡� ��ä����Τˤϡ����������ǽ�ʥ���ǥå��� �ϰʲ��Τ褦���������롣

     (index < 0 && abs(index) <= top) || (index > 0 && index <= stackspace)
0�Ϸ褷�Ƽ��������ǽ�ʥ���ǥå����ˤʤ�ʤ���

3.3 - ��������ǥå���

�ä���������Ƥ��ʤ���С� �ɤδؿ��� ��������ǥå��� �ȸƤФ��ͭ���ʥ���ǥå���������դ��롣 ����ϥ����å����̵�������Ĥ���Lua���ͤ�C�Υ����ɤ��饢���������뤿��Τ�ΤǤ��롣 ��������ǥå����ϡ�����åɤδĶ����ؿ��δĶ����쥸���ȥꡢC�δؿ��ξ���ͤ˥����������뤿��˻Ȥ� (3.4 �򻲾�)��

����åɤδĶ� (�������Х��ѿ���������) �Ͼ�˵�������ǥå��� LUA_GLOBALSINDEX �ΰ��֤ˤ��롣 �������C�δؿ��δĶ��Ͼ�˵�������ǥå��� LUA_ENVIRONINDEX �ΰ��֤ˤ��롣

�������Х��ѿ����ͤ˥��������������ѹ����뤿��ˤϡ� �Ķ��ơ��֥���Ф������̤Υơ��֥�����Ԥ��� �㤨�С��������Х��ѿ����ͤ˥�����������ˤϰʲ���Ԥ���

       lua_getfield(L, LUA_GLOBALSINDEX, varname);

3.4 - C����������

C�δؿ����������Ȥ��������Ĥ����ͤ��Ϣ�դ��� C�Υ��������� ���뤳�Ȥ��Ǥ��롣 �������ͤ� ����� �ȸƤФ졢 ���δؿ����ƤФ줿�Ȥ��ˤ��ĤǤ⥢�������Ǥ��롣 (lua_pushcclosure �򻲾�)��

C�δؿ����ƤФ��ȡ����̤ʵ�������ǥå����ˤ������ͤ����֤���롣 �����ε�������ǥå����ϥޥ��� lua_upvalueindex ����������롣 �ؿ��˴�Ϣ�դ���줿�ǽ���ͤ� lua_upvalueindex(1) �ΰ��֤ˤ��ꡢ�Ĥ��Ʊ�ͤǤ��롣 ���ߤδؿ��ξ���ͤο������礭�� n �� lua_upvalueindex(n) ��ƤӽФ��Ƥ⡢ ���������ǽ�� (������ͭ���Ǥʤ�) ����ǥå�������������롣

3.5 - �쥸���ȥ�

Lua�ϥ쥸���ȥ���󶡤��Ƥ��롣 ���������ѤߤΥơ��֥�ǡ�������Lua���ͤ��Ǽ���뤿���C�Υ����ɤ���Ȥ����Ȥ��Ǥ��롣 ���Υơ��֥�Ͼ�˵�������ǥå��� LUA_REGISTRYINDEX ���֤���Ƥ��롣 �ɤ�C�Υ饤�֥���ǡ������ݻ����뤿��ˤ��Υơ��֥��Ȥ��뤬�� ���ͤ��򤱤뤿��¾�Υ饤�֥�꤬�ȤäƤ��ʤ�����������ɬ�פ����롣 ŵ��Ū�ˤϡ��饤�֥��̾��ޤ�ʸ����Ȥ�����ʬ�Υ����ɤǻȤäƤ���C���֥������ȤΥ��ɥ쥹����ĥ饤�ȥ桼�����ǡ����򡢥����Ȥ��ƻȤ����ɤ���

�쥸���ȥ�������������ϡ�����饤�֥��Ǽ�������Ƥ����ե���󥹥ᥫ�˥���ǻȤ��Ƥ��ꡢ����椨¾����Ū�˻Ȥ��٤��Ǥʤ���

3.6 - C�ǤΥ��顼����

����Ū�ˡ�Lua�ϥ��顼�����Τ����C�� longjmp �ε�ǽ��Ȥ��� (C++��ȤäƤ���Τʤ顢�㳰��Ȥ����Ȥ�Ǥ��롣luaconf.h �ե�����򻲾ȡ�) Lua�����顼��ľ�̤���� (������­�Ȥ��������顼�Ȥ�����ʸ���顼�Ȥ����¹Ի����顼�ʤ�)�� ���顼�� ȯ�� �������Ĥޤ�Ȥ������󥰥����פ��Ԥ��롣 �ݸ�줿�Ķ� ���������򥻥åȤ��뤿��� setjmp ��Ȥ��� ���顼�ϺǤ�Ƕ���줿�����ƥ����������˥����פ��뤳�Ȥˤʤ롣

API�ΤۤȤ�ɤδؿ��ϥ��顼���㤨�Х�����ݥ��顼�ʤɤ򵯤�����ǽ�������롣 �ʲ��δؿ����ݸ�⡼�� (�Ĥޤꡢ�¹Ԥ��뤿����ݸ�줿�Ķ�����) �Ǽ¹Ԥ��뤿�ᡢ�褷�ƥ��顼�򵯤����ʤ��� lua_newstate, lua_close, lua_load, lua_pcall, and lua_cpcall��

lua_error ��Ƥ֤ȡ�C�Υ����ɤ���Lua�Υ��顼��ȯ�������뤳�Ȥ�����롣

3.7 - �ؿ��ȷ�

�ʲ���C��API�Τ��٤Ƥδؿ��ȷ��򥢥�ե��٥åȽ�˼�����


lua_Alloc

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

Lua���ơ��Ȥ��Ȥ����ꥢ���������ؿ��η��Ǥ��롣 ���ꥢ���������ؿ��� realloc �˻�����ǽ���󶡤��ʤ���Фʤ�ʤ����� �ޤä���Ʊ���ǤϤʤ��� �����ϰʲ����̤ꡣ ud: lua_newstate ���Ϥ��줿�ݥ��󥿡� ptr: �������/�Ƴ������/��������֥��å��ؤΥݥ��󥿡� osize: ���Υ֥��å��������� nsize: �������֥��å��������� osize �������ξ�硢�ޤ����ξ��˸¤ꡢptr �� NULL�ˤʤ롣 nsize �������ξ�硢������������ NULL ���֤��ʤ���Фʤ�ʤ��� osize �������Ǥʤ���硢ptr ���ؤ�����֥��å���������٤��Ǥ��롣 nsize �������Ǥʤ���硢�׵���������ʤ���Х����������� NULL ���֤��� nsize �������Ǥʤ� osize �������ξ�硢������������ malloc �Τ褦�˿����񤦤٤��Ǥ��롣 nsize �� osize �����˥����Ǥʤ���硢 osize >=nsize �Ǥ���С�Lua�ϥ������������褷�Ƽ��Ԥ��ʤ���ΤȲ��ꤷ�Ƥ��롣

�����������ؿ��δ�ñ�ʼ����򼨤����� ����� lua_newstate ������饤�֥��ǻȤäƤ��롣

static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud;     /* not used */
  (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);  /* ANSI��free(NULL)�ϸ��̤��ʤ��ȵ��ꤷ�Ƥ��� */
    return NULL;
  }
  else
    /* ANSI��realloc(NULL, size)��malloc(size)��Ʊ���ȵ��ꤷ�Ƥ��� */
    return realloc(ptr, nsize);
}


lua_atpanic

          lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);

�������ѥ˥å��ؿ������ꤷ���Ť���Τ��֤���

�ݸ�줿�Ķ��γ�¦�ǥ��顼��������ȡ�Lua�� �ѥ˥å��ؿ� ��Ƥӡ����줫�� exit(EXIT_FAILURE) ��Ƥ�ǥۥ��ȥ��ץꥱ��������λ���롣 �ѥ˥å��ؿ������ʤ����(�㤨�Х��󥰥����פ���Ȥ���)����λ���ʤ��褦�ˤǤ��롣

�ѥ˥å��ؿ��ϥ����å��ΰ��־�ˤ��륨�顼��å������˥��������Ǥ��롣


lua_call

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

�ؿ���Ƥ֡�

�ؿ���Ƥ֤ˤϡ��ʲ��μ��˽���ʤ���Фʤ�ʤ��� �ޤ����ƤӤ����ؿ��򥹥��å����Ѥࡣ ���ˡ����δؿ����Ϥ�����������̤���Ѥࡣ �Ĥޤ�ǽ�ΰ�����ǽ���Ѥࡣ �Ǹ�ˡ�lua_call ��Ƥ֡� nargs �ϥ����å����Ѥ�������ο��Ǥ��롣 ���٤Ƥΰ����ȴؿ����ͤϴؿ���Ƥ���Ȥ��˥����å������������롣 �ؿ������Ȥ��������å�������ͤ��Ѥޤ�롣 ����ͤο��� nresults �Ĥ�Ĵ�ᤵ��롣 ������ nresults �� LUA_MULTRET �ξ���Ĵ�ᤵ��ʤ��� ���ξ�硢�ؿ��� ���٤Ƥ� ����ͤ��Ѥޤ�롣 Lua������ͤ򥹥��å����֤˹礦�褦�ˤ��롣 �ؿ�������ͤϽ����̤�� (�ǽ������ͤ��ǽ��) �����å����Ѥޤ�롣 ���äƸƤӽФ���Υ����å��ΰ��־�ϡ����κǸ������ͤǤ��롣

�ƤӽФ����ؿ�����ǵ��������顼�Ͼ�����¤����(longjmp��Ȥä�)��

�ʲ���Lua�����ɤ������ʤ��Ȥ�ۥ��ȥץ�����फ��Ϥɤ�������ɤ��Τ�����򼨤���

       a = f("how", t.x, 14)
�����C�ǽ񤯤�:
    lua_getfield(L, LUA_GLOBALSINDEX, "f");          /* �Ƥִؿ� */
    lua_pushstring(L, "how");                                 /* �ǽ�ΰ��� */
    lua_getfield(L, LUA_GLOBALSINDEX, "t");            /* �ơ��֥�`t' */
    lua_getfield(L, -1, "x");                 /* t.x�η��(2���ܤΰ���)���Ѥ� */
    lua_remove(L, -2);                           /* ��������� `t' ������� */
    lua_pushinteger(L, 14);                                   /* 3���ܤΰ��� */
    lua_call(L, 3, 1);         /* 3�Ĥΰ�����1�Ĥ�����ͤǴؿ���Ƥ� */
    lua_setfield(L, LUA_GLOBALSINDEX, "a");        /* �������Х��ѿ� `a' ������ */
��Υ����ɤϡ����礬���Ƥ���פ��Ȥ����ܡ� �ǽ�Ū�˥����å��ϸ��ξ��֤���äƤ��롣 ������ɤ��ץ�����ߥ󥰺�ˡ�Ǥ���ȹͤ����롣


lua_CFunction

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

C�δؿ��η���

Ŭ�ڤ�Lua�Ȥ��Ȥꤹ��ˡ�C�δؿ��ϡ� ����������ͤμ����Ϥ���ˡ���������ʲ��μ��˽���ʤ���Фʤ�ʤ��� C�δؿ���Lua����ΰ����򥹥��å��˽����̤������� (�ǽ�ΰ������ǽ���Ѥޤ��)�� �Ĥޤꡢ�ؿ��γ��ϻ����Ǥϡ� lua_gettop(L) �ϴؿ���������ä������ο����֤��� �ǽ�ΰ���(�⤷�����)�ϥ���ǥå���1�ǡ��Ǹ�ΰ����ϥ���ǥå��� lua_gettop(L) �Ǥ��롣 Lua���ͤ��֤��ˤϡ�C�δؿ���ñ�˥����å��ˤ����ͤ�����̤� (�ǽ������ͤ�ǽ��) �Ѥߡ�����ͤο����֤��������ɤ��� ����ͤ�겼�Υ����å��ˤ���;�פ��ͤϤ��٤�Lua�ˤ�äƼΤƤ��롣 Lua�δؿ���Ʊ�͡�Lua����ƤФ��C�δؿ��Ǥ⡢�������������ͤ��֤����Ȥ��Ǥ��롣

��Ȥ��ơ����ѸĤο��ͤΰ������ꡢ����ʿ�Ѥȹ�פ��֤��ؿ���ʲ��˼�����

       static int foo (lua_State *L) {
         int n = lua_gettop(L);    /* �����ο� */
         lua_Number sum = 0;
         int i;
         for (i = 1; i <= n; i++) {
           if (!lua_isnumber(L, i)) {
             lua_pushstring(L, "�ؿ� `average' �ΰ���������������ޤ���");
             lua_error(L);
           }
           sum += lua_tonumber(L, i);
         }
         lua_pushnumber(L, sum/n);        /* �ǽ������� */
         lua_pushnumber(L, sum);         /* 2���ܤ������ */
         return 2;                   /* ����ͤο� */
       }


lua_checkstack

          int lua_checkstack (lua_State *L, int extra);

�����å��˾��ʤ��Ȥ� extra �Ĥζ��������åȤ����뤳�Ȥ��ݾڤ��롣 �⤷�����å��򤽤Υ������ޤǿ��Ф��ʤ���� false ���֤��� �����å������Ǥ˻��ꤵ�줿Ĺ������Ĺ����С� �虜�虜�����å���̤᤿�ꤻ���������Ѥ��ʤ���


lua_close

          void lua_close (lua_State *L);

�Ϥ��줿Lua���ơ�����Τ��٤ƤΥ��֥������Ȥ��˴��� (�⤷����Х��١������쥯�����᥿�᥽�åɤ�Ƥ�)�� ���ơ�����ǻȤ��Ƥ������٤Ƥ�ưŪ�����������롣 �ץ�åȥե�����ˤ�äƤϡ� �ۥ��ȥץ�����ब��λ����Ȥ��ˤ��٤ƤΥ꥽��������ưŪ�˲�������뤿�ᡢ ���δؿ���Ƥ�ɬ�פ��ʤ����⤷��ʤ��� �������ǡ����䥦���֥����ФΤ褦��Ĺ���ּ¹Ԥ���ץ������Ǥϡ� ����꥽���������礹��Τ��򤱤뤿��ˡ� ɬ�פʤ��ʤä����ơ��ȤϤ����˲�������ɬ�פ������������


lua_concat

          void lua_concat (lua_State *L, int n);

�����å��ȥåפ��� n �Ĥ��ͤ�Ϣ�뤷�����������������̤򥹥��å��ȥåפ˺ܤ��롣 �⤷ n ��1�ʤ�ϡ���̤Ϥ���1�Ĥ�ʸ����Ǥ��� (�פ���˲��⤷�ʤ�)�� �⤷ n ��0�ʤ�С���̤϶�ʸ����Ǥ��롣 Ϣ����̾��Lua�ΰ�̣���˽��äƹԤ��� (2.5.4 �򻲾�)��


lua_cpcall

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

C�δؿ� func ���ݸ�⡼�ɤǸƤ֡� func �ϥ����å���1�Ĥΰ�����ud ����ĥ饤�ȥ桼�����ǡ������ܤä����֤dz��Ϥ��롣 ���顼�������ä���硢 lua_cpcall �� lua_pcall ��Ʊ�����顼�����ɤ��֤������顼���֥������Ȥ򥹥��å��ȥåפ��֤��� �����Ǥʤ����0���֤��������å��ϲ����Ѥ��ʤ��� func �����֤�����ͤϤ��٤ƼΤƤ��롣


lua_createtable

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

���������Υơ��֥���ꡢ�����å����Ѥࡣ ���ο������ơ��֥�� narr �Ĥ��������Ǥ� nrec �Ĥ����������ǤΤ���γ�����ƺѤ߶��֤���äƤ��롣 ���λ���������Ƥϡ����Υơ��֥뤬������������Ǥ���ĤǤ������Ȥ狼�äƤ���������Ω�ġ� ����ʳ��ξ��ϡ��ؿ� lua_newtable ��ȤäƤ��ɤ���


lua_dump

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

�ؿ���Х��ʥ����󥯤Ȥ��ƥ���פ��롣 �����å��ȥåפ�Lua�δؿ���1�ļ�����ꡢ1�ĤΥХ��ʥ����󥯤��������롣 ����ϡ��Ƥӥ����ɤ��줿�Ȥ�������פ��줿��Τ�Ʊ���δؿ����롣 ����󥯤γ�������������Ȥ��� lua_dump �Ϥ�����񤭹��ि��˴ؿ� writer (lua_Writer �򻲾�) ��data ��Ϳ���ƸƤ֡�

����ͤ� writer �κǸ�θƤӽФ����֤������顼�����ɤǤ��롣 0�ϥ��顼�ʤ���ɽ����

���δؿ��ϥ����å�����Lua�δؿ���������ʤ���


lua_equal

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

���������ǽ�ʥ���ǥå��� index1 �� index2 �ΰ��֤ˤ���2�Ĥ��ͤ����������1���֤��� �����Ǥʤ����0���֤��� �ɤ��餫�Υ���ǥå�����ͭ���Ǥʤ��Ȥ���0���֤��� ��Ӥ�Lua�� == �黻�Ҥΰ�̣���˽��äƹԤ��� (�Ĥޤꡢ�᥿�᥽�åɤ�Ƥ־�礬����)��


lua_error

          int lua_error (lua_State *L);

Lua���顼���������롣 �Ƥ����ˡ����顼��å����� (�ºݤˤϤɤ�ʷ����ͤǤ��ɤ�) �򥹥��å��ȥåפ��֤��ʤ���Фʤ�ʤ��� ���δؿ��ϥ��󥰥����פ�Ԥ��Τǡ��褷����äƤ��ʤ� (luaL_error �򻲾�)��


lua_gc

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

���١������쥯�������椹�롣

���δؿ��ϰ��� what ���ͤ˱����Ƥ����Ĥ��λŻ���Ԥ���


lua_getallocf

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

�Ϥ��줿���ơ��ȤΥ��ꥢ���������ؿ����֤��� ud �� NULL �Ǥʤ���С� Lua�� lua_newstate ���Ϥ��줿�ݥ��󥿤� *ud �˳�Ǽ���롣


lua_getfenv

          void lua_getfenv (lua_State *L, int index);

���ꤷ������ǥå������ͤδĶ��ơ��֥�򥹥��å����Ѥࡣ


lua_getfield

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

�� t[k] �򥹥��å����Ѥࡣ ������ t �ϻ��ꤷ��ͭ���ʥ���ǥå��� index ���ͤǤ��롣 Lua����Ǥ�Ʊ�ͤˡ����δؿ��� "index" ���٥�ȤΥ᥿�᥽�åɤ�Ƥ־�礬���� (2.8 �򻲾�)��


lua_getglobal

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

�������Х��ѿ� name ���ͤ򥹥��å����Ѥࡣ ����ϥޥ����Ȥ����������Ƥ��롣

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


lua_getmetatable

          int lua_getmetatable (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤΥ᥿�ơ��֥�򥹥��å����Ѥࡣ ����ǥå�����ͭ���Ǥʤ����������ͤ��᥿�ơ��֥����äƤ��ʤ���С� ���δؿ���0���֤��������å��ˤϲ����Ѥޤʤ���


lua_gettable

          void lua_gettable (lua_State *L, int index);

�� t[k] �򥹥��å����Ѥࡣ ������ t ���Ϥ��줿ͭ���ʥ���ǥå��� index ���ͤǡ� k �ϥ����å��ȥåפ��ͤǤ��롣

���δؿ��ϥ����å����饭���� (�����˷�̤��֤�����) �������� Lua����Ǥ�Ʊ�ͤˡ����δؿ��� "index" ���٥�ȤΥ᥿�᥽�åɤ�Ƥ־�礬���� (2.8 �򻲾�)��


lua_gettop

          int lua_gettop (lua_State *L);

�����å��ȥåפ����ǤΥ���ǥå������֤��� ����ǥå�����1����Ϥޤ�Τǡ���������ͤϥ����å������ǿ��������� (�����ƥ����ϥ����å������Ǥ��뤳�Ȥ��̣����)��


lua_insert

          void lua_insert (lua_State *L, int index);

���ꤷ�����֤�������Ǥ򤺤餷�ƶ������ڡ������ꡢ�����å��ȥåפ����Ǥ򤽤ΰ��֤˰�ư���롣 ��������ǥå����ϡ��ºݤΥ����å����֤ǤϤʤ����ᡢ����Ǥ��ʤ���


lua_Integer

          typedef ptrdiff_t lua_Integer;

�����ͤ�ɽ�����뤿��Ρ�Lua API�ǻȤ��뷿��

�ǥե���ȤǤ� ptrdiff_t �Ǥ��롣 ������̾�ޥ��󤬡ֲ�Ŭ�ˡװ����������������Ǥ��롣


lua_isboolean

          int lua_isboolean (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��֡��ꥢ�󷿤Ǥ����1�������Ǥʤ����0���֤���


lua_iscfunction

          int lua_iscfunction (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�C�δؿ��Ǥ����1�������Ǥʤ����0���֤���


lua_isfunction

          int lua_isfunction (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��ؿ� (C��Lua�ɤ��餫��) �Ǥ����1�������Ǥʤ����0���֤���


lua_islightuserdata

          int lua_islightuserdata (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��饤�ȥ桼�����ǡ����Ǥ����1�������Ǥʤ����0���֤���


lua_isnil

          int lua_isnil (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ� nil �Ǥ����1�������Ǥʤ����0���֤���


lua_isnumber

          int lua_isnumber (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ����ͤ������ͤ��Ѵ��Ǥ���ʸ����Ǥ����1�������Ǥʤ����0���֤���


lua_isstring

          int lua_isstring (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�ʸ���󤫿��ͤǤ����1�������Ǥʤ����0���֤��� (���ͤξ�硢�����ʸ������Ѵ������)


lua_istable

          int lua_istable (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��ơ��֥�Ǥ����1�������Ǥʤ����0���֤���


lua_isthread

          int lua_isthread (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�����åɤǤ����1�������Ǥʤ����0���֤���


lua_isuserdata

          int lua_isuserdata (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��桼�����ǡ��� (�ե뤫�饤�Ȥɤ��餫��) �Ǥ����1�������Ǥʤ����0���֤���


lua_lessthan

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

���������ǽ�ʥ���ǥå��� index1 ���ͤ����������ǽ�ʥ���ǥå��� index2 ���ͤ��⾮�������1�������Ǥʤ����0���֤��� �ɤ��餫�Υ���ǥå�����ͭ���Ǥʤ�����0���֤��� ��Ӥ�Lua�� < �黻�Ҥΰ�̣���˽��äƹԤ��� (�Ĥޤꡢ�᥿�᥽�åɤ�Ƥ־�礬����)��


lua_load

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

Lua����󥯤�����ɤ��롣 ���顼���ʤ���С� lua_load �ϥ���ѥ��뤷������󥯤�Lua�δؿ��Ȥ��ƥ����å��ȥåפ��Ѥࡣ �����Ǥʤ���С����顼��å��������Ѥࡣ lua_load ������ͤϰʲ����̤ꡣ

lua_load �ϥ���󥯤��ƥ����Ȥ��Х��ʥ꤫��ưŪ�˸��Ф�������˱����ƥ���󥯤�����ɤ��� (�ץ������ luac �򻲾�)��

lua_load �ϥ���󥯤��ɤ߹��ि��˥桼�����󶡤��� reader �ؿ���Ȥ� (see lua_Reader �򻲾�)�� data �����Ϥ��Υ꡼���ؿ����Ϥ�����ͤǤ��롣

chunkname �����ϥ���󥯤�̾����Ϳ���롣 ����ϥ��顼��å�������ǥХå�����ǻȤ��� (3.8 �򻲾�)��


lua_newstate

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

��������Ω�������ơ��Ȥ��롣 ���ơ��Ȥ���ʤ���� (������­�Τ����)��NULL ���֤��� ���� f �ϥ����������ؿ��Ǥ��롣 Lua�Ϥ��Υ��ơ��ȤΤ���Τ��٤ƤΥ�����ݤ򤳤δؿ���ȤäƹԤ��� 2���ܤΰ��� ud �ϡ����Υ���������������Ϥ����ݥ��󥿤Ǥ��롣


lua_newtable

          void lua_newtable (lua_State *L);

���������Υơ��֥���äƥ����å����Ѥࡣ lua_createtable(L, 0, 0) ��Ʊ���Ǥ��롣


lua_newthread

          lua_State *lua_newthread (lua_State *L);

����������åɤ��äƥ����å����Ѥߡ� ���ο���������åɤ�ɽ�� lua_State �ؤΥݥ��󥿤��֤��� ���δؿ����֤������������ơ��Ȥϸ��Υ��ơ��ȤȤ��٤ƤΥ������Х륪�֥������� (�ơ��֥�Ȥ�) ��ͭ���뤬����Ω�����¹ԥ����å�����ġ�

����åɤ��Ĥ������˴���������Ū�ʴؿ��Ϥʤ��� ����åɤ�¾��Lua���֥�������Ʊ�͡����١������쥯�������оݤǤ��롣


lua_newuserdata

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

���δؿ��ϻ��ꤵ�줿�������Υ���֥��å��������ơ� ���Υ��ɥ쥹����Ŀ������ե�桼�����ǡ����򥹥��å����Ѥߡ� ���Υ��ɥ쥹���֤���

�桼�����ǡ�����Lua���C���ͤ�ɽ�����롣 �ե�桼�����ǡ��� �ϥ���֥��å���ɽ���� ����� (�ơ��֥��Ʊ���褦��) ���֥������ȤǤ��롣 ��������ɬ�פ����ꡢ�ȼ��Υ᥿�ơ��֥����Ĥ��Ȥ��Ǥ��� ���١������쥯����󤵤��Τ򸡽ФǤ��롣 �ե�桼�����ǡ����� (rawequal�β��Ǥ�) ���켫�Ȥ���Ӥ����Ȥ�������������

Lua�� gc �᥿�᥽�åɤ���ĥե�桼�����ǡ�����������Ȥ��� Lua�ϥ᥿�᥽�åɤ�Ƥӡ��桼�����ǡ����˥ե����ʥ饤���Ѥߤΰ����դ��롣 ���Υ桼�����ǡ������⤦���ٲ�������ȡ�Lua���б���������������롣


lua_next

          int lua_next (lua_State *L, int index);

�����å����饭������Ф��� ���ꤷ������ǥå����Υơ��֥뤫�饭�����ͤΥڥ� (���Ф��������Ρּ��פΥڥ�) ���Ѥࡣ ����ʾ����Ǥ��ʤ���С� lua_next �� (�����Ѥޤ���) 0���֤���

ŵ��Ū�ʽ��ϼ��Τ褦�ˤʤ롣

       /* �ơ��֥�ϥ����å��� `t' �ΰ��֤ˤ���Ȥ��� */
       lua_pushnil(L);  /* �ǽ�Υ��� */
       while (lua_next(L, t) != 0) {
         /* �֥����ץ���ǥå���-2�����͡פϥ���ǥå���-1�ΰ��֤ˤ��� */
         printf("%s - %s\n",
           lua_typename(L, lua_type(L, -2)), lua_typename(L, lua_type(L, -1)));
         lua_pop(L, 1);  /* ���͡פ������֥����פϼ��η����֤��Τ���˻Ĥ� */
       }

�ơ��֥���󤹤�֡� ��������ʪ��ʸ����Ǥ��뤫�ɤ���Ƚ��ʤ��ʤ顢�������Ф���ľ�� lua_tolstring ��Ƥ�ǤϤʤ�ʤ��� lua_tolstring �ϻ��ꤷ������ǥå����ˤ����ͤ� �Ѥ��� ���ᡢ���� lua_next �θƤӽФ����𤵤��뤳�Ȥ�Ф��Ƥ����褦�ˡ�


lua_Number

          typedef double lua_Number;

Lua�ο��ͤη��� �ǥե���ȤǤϡ������double�Ǥ��뤬�� luaconf.h ���Ѥ��뤳�Ȥ��Ǥ��롣

����ե�����졼�����ե�������ѹ����뤳�Ȥǡ� Lua�����ͤ��Ф���¾�η� (float��long�ʤ�) ��Ȥ��褦�ˤǤ��롣


lua_objlen

          size_t lua_objlen (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤΡ�Ĺ���פ��֤��� ʸ����ξ��Ϥ���ʸ�����Ĺ���� �ơ��֥�ξ���Ĺ���黻�� (`#��) �η�̡� �桼�����ǡ����ξ��ϳ�����Ƥ�줿����֥��å��Υ������� ����ʳ��ξ���0���֤���


lua_pcall

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

�ؿ����ݸ�⡼�ɤǸƤ֡�

nargs �� nresults �� lua_call ��Ʊ���Ǥ��롣 �⤷���顼���ʤ���� lua_pcall �� lua_call �Ȥޤä���Ʊ���褦��ư��롣 ���������������顼�����������ϡ� lua_pcall �Ϥ������館�ơ� 1�Ĥ��� (���顼��å�����) �򥹥��å����Ѥ�ǥ��顼�����ɤ��֤��� lua_call Ʊ�͡� lua_pcall �Ͼ�˴ؿ��Ȥ��ΰ����򥹥��å������������

�⤷ errfunc ��0�Ǥ���С������å����֤��줿���顼��å����������Τ˸��Υ��顼��å������Ǥ��롣 �����Ǥʤ���С�errfunc �� ���顼�ϥ�ɥ�ؿ� �Υ����å�����ǥå�������ꤹ�� (���ߤμ����Ǥϡ���������ǥå����ϻ���Ǥ��ʤ�)�� �¹Ի����顼��������ȡ����顼��å�����������Ȥ��Ƥ��δؿ����ƤФ졢 ��������ͤ� lua_pcall �����֤���륨�顼��å������Ȥʤ롣

ŵ��Ū�ˤϡ����顼�ϥ�ɥ�ؿ��ϡ����顼��å������˥����å��ȥ졼���Τ褦�ʥǥХå�������դ��ä���Τ˻Ȥ��� �������ä������ lua_pcall ������ä���ˤϤ⤦�����å���������Ƥ��뤿�ᡢ����뤳�Ȥ��Ǥ��ʤ���

lua_pcall �ؿ�����������0���֤��� ���顼�ξ��ϰʲ��Υ��顼�����ɤΤ����줫���֤� (lua.h ���������Ƥ���)��


lua_pop

          void lua_pop (lua_State *L, int n);

�����å����� n �Ĥ����Ǥ��������


lua_pushboolean

          void lua_pushboolean (lua_State *L, int b);

�� b �Υ֡��ꥢ���ͤ򥹥��å����Ѥࡣ


lua_pushcclosure

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

������C�Υ���������򥹥��å����Ѥࡣ

C�δؿ�����Ȥ��������Ĥ����ͤ��Ϣ�դ��� C�Υ��������� ���뤳�Ȥ��Ǥ��� (see 3.4)�� �������ͤϤ��δؿ����ƤФ줿�Ȥ��ˤ��ĤǤ⥢�������Ǥ��롣 C�δؿ����ͤ��Ϣ�դ���ˤϡ� �ޤ��������ͤ򥹥��å����Ѥ� (ʣ�����ͤ�������ϡ��ǽ���ͤ�ǽ���Ѥ�)�� ���� lua_pushcclosure��Ƥӡ� C�δؿ����äƥ����å��˥ץå��夹�롣 ���� n �ϴؿ��˴�Ϣ�դ����ͤο��򼨤��� lua_pushcclosure �ϥ����å����餽�����ͤ��������


lua_pushcfunction

          void lua_pushcfunction (lua_State *L, lua_CFunction f);

C�δؿ��򥹥��å����Ѥࡣ ���δؿ���C�δؿ��ؤΥݥ��󥿤������ꡢ�ؿ� ����Lua�ͤ򥹥��å����Ѥࡣ �����ͤ��ƤФ��ȡ��б�����C�δؿ����ƤФ�롣

Lua����Ͽ����ؿ��ϰ���������ͤ�����Ϥ�����ˡ� ���������˽���ʤ�����Ĥ�ʤ� (lua_CFunction �򻲾�)��

lua_pushcfunction(L, f) �θƤӽФ��� lua_pushcclosure(L, f, 0) ��Ʊ���Ǥ��롣


lua_pushfstring

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

�񼰲�ʸ����򥹥��å����Ѥߡ�����ʸ�����ؤ��ݥ��󥿤��֤��� �����C�δؿ� sprintf �˻��Ƥ��뤬�������Ĥ����פʰ㤤�����롣


lua_pushinteger

          void lua_pushinteger (lua_State *L, lua_Integer n);

�� n ����Ŀ��ͤ򥹥��å����Ѥࡣ


lua_pushlightuserdata

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

�饤�ȥ桼�����ǡ����򥹥��å����Ѥࡣ

�桼�����ǡ�����Lua���C���ͤ�ɽ�����롣 �饤�ȥ桼�����ǡ��� �ϥݥ��󥿤�ɽ���� ����� (���ͤ�Ʊ���褦��) �ͤǤ��롣 �����Ϥ������᥿�ơ��֥���������(�������ʤ��Τ�) ����⤵��ʤ��� �饤�ȥ桼�����ǡ����ϡ�Ʊ��C�Υ��ɥ쥹����ġ֤ɤΡץ饤�ȥ桼�����ǡ����Ȥ���������


lua_pushlstring

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

s ���ؤ������� len ��ʸ����򥹥��å����Ѥࡣ Lua��Ϳ����줿ʸ���������Ū�˥��ԡ����� (�ޤ��Ϻ����Ѥ���) ���ᡢ s���ؤ�����ϴؿ�����ä����Ȥ����˲������뤤�Ϻ����Ѥ��Ƥ褤�� ʸ����������ޤ줿������ޤ�Ǥ��Ƥ��ɤ���


lua_pushnil

          void lua_pushnil (lua_State *L);

nil�ͤ򥹥��å����Ѥࡣ


lua_pushnumber

          void lua_pushnumber (lua_State *L, lua_Number n);

�� n ����Ŀ��ͤ򥹥��å����Ѥࡣ


lua_pushstring

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

s���ؤ�������üʸ����򥹥��å����Ѥࡣ Lua��Ϳ����줿ʸ���������Ū�˥��ԡ����� (�ޤ��Ϻ����Ѥ���) ���ᡢ s ���ؤ������ؿ�����ä����Ȥ����˲������뤤�Ϻ����Ѥ��Ƥ褤�� ʸ����������ޤ줿������ޤळ�Ȥ��Ǥ��ʤ��� �ǽ�Υ����ǽ�ü�����ΤȲ��ꤵ��롣


lua_pushthread

          void lua_pushthread (lua_State *L);

L��ɽ������åɤ򥹥��å����Ѥࡣ


lua_pushvalue

          void lua_pushvalue (lua_State *L, int index);

���ꤷ��ͭ���ʥ���ǥå����ˤ������ǤΥ��ԡ��򥹥��å����Ѥࡣ


lua_pushvfstring

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

lua_pushfstring ��Ʊ���Ǥ��뤬�� ���Ѱ���������� va_list ���Ϥ������ۤʤ롣


lua_rawequal

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

���������ǽ�ʥ���ǥå��� index1 �� index2 �� �ץ�ߥƥ��֤������� (�Ĥޤ�᥿�᥽�åɤ�ƤФʤ�) �Ȥ�1���֤��� �����Ǥʤ����0���֤��� �ɤ��餫�Υ���ǥå�����ͭ���Ǥʤ��Ȥ���0���֤���


lua_rawget

          void lua_rawget (lua_State *L, int index);

lua_gettable ��Ʊ���Ǥ��뤬�� ���Υ���������Ԥ� (�Ĥޤ�᥿�᥽�åɤ�ƤФʤ�) �����ۤʤ롣


lua_rawgeti

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

�� t[n] �򥹥��å����Ѥࡣ ������ t �ϻ��ꤷ��ͭ���ʥ���ǥå��� index ���ͤǤ��롣 ��������Υ���������Ԥ��� �Ĥޤ�᥿�᥽�åɤ�ƤФʤ���


lua_rawset

          void lua_rawset (lua_State *L, int index);

lua_settable ��Ʊ���Ǥ��뤬�� ���������Ǥ��������ۤʤ� (�᥿�᥽�åɤ�ƤФʤ�)��


lua_rawseti

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

t[n] = v ��Ʊ�����Ȥ�Ԥ��� ������ t �ϻ��ꤷ��ͭ���ʥ���ǥå��� index ���ͤǡ� v �ϥ����å��ȥåפ��ͤǤ��롣

���δؿ����ͤ򥹥��å������������ ���������������Ԥ��� �Ĥޤ�᥿�᥽�åɤ�ƤФʤ���


lua_Reader

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

lua_load �ǻȤ��꡼�����ؿ��� ����󥯤ο����ʥԡ�����ɬ�פˤʤ뤿�Ӥˡ�data �������դ��ƥ꡼�������ƤФ�롣 �꡼�����ϥ���󥯤ο����ʥԡ�������᤿����֥��å���ؤ��ݥ��󥿤��֤��� ����Ĺ���� size �˥��åȤ��ʤ���Фʤ�ʤ��� �֥��å��ϥ꡼�����ؿ����⤦���ٸƤФ��ޤ�¸�ߤ��ʤ���Фʤ�ʤ��� ����󥯤κǸ��ã�������Ȥ�������ˤ� NULL ���֤��� �꡼�����ؿ���1�ʾ��Ǥ�դΥ������Υԡ������֤����Ȥ��Ǥ��롣


lua_register

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

C�δؿ� f �򥰥����Х��ѿ� name �ο������ͤȤ��ƥ��åȤ��롣 ����ϥޥ����Ȥ����������Ƥ��롣

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


lua_remove

          void lua_remove (lua_State *L, int index);

���ꤷ��ͭ���ʥ���ǥå��������Ǥ�������� ������Ǥ򤺤餷�Ʒ�֤����롣 ��������ǥå����ϡ��ºݤΥ����å����֤Ǥʤ����ᡢ����Ǥ��ʤ���


lua_replace

          void lua_replace (lua_State *L, int index);

�����å��ȥåפ����Ǥ���ꤷ�����֤ذ�ư���롣 �����å��ȥåפ��ͤϼ������� ¾�Τɤ����Ǥ⤺�餵�ʤ��� �Ĥޤ���ꤷ�����֤��ͤ��֤������롣


lua_resume

          int lua_resume (lua_State *L, int narg);

���ꤷ������åɤΥ��롼�����Ƴ����롣

���롼����򳫻Ϥ��뤿��ˤϡ��ޤ�����������åɤ��� (lua_newthread �򻲾�)�� ���˥ᥤ��ؿ���Ǥ�ոĤΰ����򥹥��å����Ѥߡ� nargs �˰����ο����Ϥ��ơ� lua_resume ��Ƥ֡� ���롼�������Ǥ��줿��¹Խ�λ�����顢�ƤӽФ�������롣 ��äƤ����Ȥ��������å��ˤ� lua_yield ���Ϥ��줿�ͤ������Τδؿ������֤��줿�ͤ����٤��Ѥޤ�Ƥ��롣 ���롼����yield������硢lua_resume �� LUA_YIELD ���֤��� ���롼���󤬥��顼�ʤ��¹Խ�λ��������0���֤��� ���顼�����������ϥ��顼�����ɤ��֤� (lua_pcall �򻲾�)�� ���顼�ξ�硢�����å��ϴ����ᤵ��Ƥ��餺�����äƤ��ξ�ǥǥХå�API��Ȥ����Ȥ��Ǥ��롣 �����å��ȥåפ˥��顼��å��������֤���롣 ���롼�����Ƴ�����ˤϡ�yied �����֤�����̤Ȥ����Ϥ��ͤ����򥹥��å��˵����� lua_resume ��Ƥ֡�


lua_setallocf

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

���ꤵ�줿���ơ��ȤΥ����������ؿ��� f �� ud ���ѹ����롣


lua_setfenv

          int lua_setfenv (lua_State *L, int index);

�����å�����ơ��֥������������ꤷ������ǥå������ͤο������Ķ��Ȥ������ꤹ�롣 ���ꤷ������ǥå������ͤ��ؿ�������åɡ��桼�����ǡ����Τɤ�Ǥ�ʤ���С� lua_setfenv ��0���֤��� �����Ǥʤ����1���֤���


lua_setfield

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

t[k] = v ��¹Ԥ��롣 ������ t �ϻ��ꤷ��ͭ���ʥ���ǥå��� index ���ͤǡ� v �ϥ����å��ȥåפ��ͤǤ��롣

���δؿ����ͤ򥹥��å��������롣 Lua����ǤΤ褦�ˡ����δؿ��� "newindex" ���٥�ȤΥ᥿�᥽�åɤ�Ƥ־�礬���� (2.8 �򻲾�)��


lua_setglobal

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

�����å������ͤ������������򥰥����Х��ѿ� name �ο������ͤȤ������ꤹ�롣 ����ϥޥ����Ȥ����������Ƥ��롣

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


lua_setmetatable

          int lua_setmetatable (lua_State *L, int index);

�����å�����ơ��֥����������������ꤷ�����������ǽ�ʥ���ǥå������ͤο������᥿�ơ��֥�Ȥ������ꤹ�롣


lua_settable

          void lua_settable (lua_State *L, int index);

t[k] = v ��¹Ԥ��롣 ������ t �ϻ��ꤷ��ͭ���ʥ���ǥå��� index ���ͤǡ� v �ϥ����å��ȥåפ��ͤǡ� k �Ϥ��ΤҤȤIJ����ͤǤ��롣

���δؿ��ϥ������ͤ�ξ���򥹥��å������������ Lua����ǤΤ褦�ˡ����δؿ��� "newindex" ���٥�ȤΥ᥿�᥽�åɤ�Ƥ־�礬���� (2.8 �򻲾�)��


lua_settop

          void lua_settop (lua_State *L, int index);

Ǥ�դμ��������ǽ�ʥ���ǥå����ޤ���0�������ꡢ �����å��ȥåפ򤽤Υ���ǥå��������ꤹ�롣 �������ȥåפ��Ť���Τ���礭����С����������Ǥ� nil �������롣 index ��0�ξ��ϡ������å����Ǥ����٤ƺ������롣


lua_State

          typedef struct lua_State lua_State;

Lua���󥿥ץ꥿�ξ������Τ��ݻ�������Ʃ���ʹ�¤�Ρ� Lua�饤�֥��ϥ������Х��ѿ���ȤäƤ��ʤ��Τǡ������˺�����ǽ�Ǥ��롣 ���ơ��Ȥ˴ؤ��뤹�٤Ƥξ���Ϥ��ι�¤�Τ��ݻ�����Ƥ��롣

���Υ��ơ��ȤؤΥݥ��󥿤ϡ� ̵����Lua���ơ��Ȥ�������� lua_newstate ������ơ� �饤�֥��Τ��٤Ƥδؿ��Ǻǽ�ΰ����Ȥ����Ϥ��ʤ���Фʤ�ʤ���


lua_status

          int lua_status (lua_State *L);

����å� L �ξ��֤��֤���

�̾�Υ���åɤξ��֤�0�Ǥ��롣 ����åɤ����顼��λ���Ƥ���Х��顼�����ɡ� ����åɤ����Ǥ��Ƥ���� LUA_YIELD ���֤���


lua_toboolean

          int lua_toboolean (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�C�Υ֡��ꥢ���� (0�ޤ���1) ���Ѵ����롣 Lua�Ǥξ��Ƚ�Ǥ�Ʊ�ͤˡ� lua_toboolean �� false �� nil �ʳ��Τ��٤Ƥ��ͤ��Ф���1���֤��� �����Ǥʤ����0���֤��� ͭ���Ǥʤ�����ǥå�������ꤷ������0���֤��� �⤷�����Υ֡��ꥢ���ͤ�����Ĵ�٤������ϡ� lua_isboolean ���ͤη���Ƚ�ꤹ�뤳�ȡ�


lua_tocfunction

          lua_CFunction lua_tocfunction (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�C�δؿ����Ѵ����롣 �����ͤ�C�δؿ��Ǥʤ���Фʤ�ʤ�������ʳ��Ǥ� NULL ���֤���


lua_tointeger

          lua_Integer lua_tointeger (lua_State *L, int idx);

���ꤷ�����������ǽ�ʥ���ǥå�����Lua���ͤ�����դ������� lua_Integer ���Ѵ����롣 ����Lua���ͤϿ��ͤ������ͤ��Ѵ��Ǥ���ʸ����Ǥʤ���Фʤ�ʤ� (2.2.1 �򻲾�)�� ����ʳ��ξ�硢lua_tointeger ��0���֤���

���ͤ������Ǥʤ���С����餫��̤�������ˡ�������˴ݤ�롣


lua_tolstring

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

���ꤷ�����������ǽ�ʥ���ǥå�����Lua���ͤ�ʸ���� (const char*) ���Ѵ����롣 �⤷ len �� NULL �Ǥʤ���С� *len ��ʸ�����Ĺ�������ꤵ��롣 ����Lua���ͤ�ʸ���󤫿��ͤǤʤ���Фʤ餺�� ����ʳ��ξ�硢���δؿ��� NULL ���֤��� �⤷�����ͤ����ͤǤ���С� lua_tolstring �ϥ����å���Τ��μºݤ��ͤ�ʸ����� �Ѵ����� (�����Ѵ��ϥơ��֥�����Υ������Ф��� lua_tolstring ��Ȥä��Ȥ��� lua_next ���𤵤���)��

lua_tolstring ��Lua���ơ���������ʸ�����ؤ��������˥��饤����Ȥ��줿�ݥ��󥿤��֤��� ����ʸ����ϡ����κǸ��ɬ������ (`\0��) ����� (C�Ǥ褯���褦��) ���� ��������ˤ⥼����ޤळ�Ȥ����롣 Lua�ϥ��١������쥯��������äƤ��뤿�ᡢ lua_tolstring ���֤����ݥ��󥿤��������ͤ������å�����������줿���ͭ���Ǥ���³����Ȥ����ݾڤϤʤ���


lua_tonumber

          lua_Number lua_tonumber (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå����ˤ���Lua���ͤ���ͤ��Ѵ����� (lua_Number �򻲾�)�� ����Lua���ͤϿ��ͤ������ͤ��Ѵ��Ǥ���ʸ����Ǥʤ���Фʤ�ʤ� (2.2.1 �򻲾�)�� ����ʳ��ξ�硢lua_tonumber ��0���֤���


lua_topointer

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

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�C�����ѥݥ��� (void*) ���Ѵ����롣 �����ͤϡ��桼�����ǡ������ơ��֥롢����åɡ��ؿ��Τ����줫�Ǥ��롣 ����ʳ��ʤ� lua_topointer �� NULL ���֤��� Lua�ϰۤʤ륪�֥������Ȥ��Ф��Ƥϰۤʤ�ݥ��󥿤��֤����Ȥ��ݾڤ��롣 �ݥ��󥿤��餽�θ����ͤ��Ѵ�����ľ��Ū����ˡ��̵����

ŵ��Ū�ˤϡ����δؿ��ϥǥХå�����Τ���ˤ����Ȥ��롣


lua_tostring

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

len �� NULL ���Ϥ��� lua_tolstring ��Ƥ֤Τ�Ʊ����


lua_tothread

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

���ꤷ�����������ǽ�ʥ���ǥå������ͤ�Lua�Υ���å� (lua_State* ��ɽ�����) ���Ѵ����롣 �����ͤϥ���åɤǤʤ���Фʤ餺������ʳ��Ǥ� NULL ���֤���


lua_touserdata

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

���ꤷ�����������ǽ�ʥ���ǥå������ͤ��ե�桼�����ǡ����Ǥ���С����Υ֥��å��Υ��ɥ쥹���֤��� �饤�ȥ桼�����ǡ����Ǥ���С����Υݥ��󥿤��֤��� �ɤ���Ǥ�ʤ���� NULL ���֤���


lua_type

          int lua_type (lua_State *L, int index);

���ꤷ�����������ǽ�ʥ���ǥå������ͤη����֤��� ͭ���Ǥʤ�����ǥå��� (�Ĥޤꤽ�ΰ��֤����Ǥ��ʤ�) �ξ��� LUA_TNONE ���֤��� lua_type ���֤����� lua.h ���������Ƥ���ʲ�������Ǥ��롣

LUA_TNIL
LUA_TNUMBER
LUA_TBOOLEAN
LUA_TSTRING
LUA_TTABLE
LUA_TFUNCTION
LUA_TUSERDATA
LUA_TTHREAD
LUA_TLIGHTUSERDATA


lua_typename

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

tp ����������̾�����֤��� tp �� lua_type ���֤��ͤΤ����줫�Ǥʤ���Фʤ�ʤ���


lua_Writer

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

lua_dump �ǻȤ��饤�����ؿ��� ����������󥯤Υԡ�������������뤿�Ӥˡ� �񤭹��ߥХåե� (p)�����Υ����� (sz)�� ����� lua_dump ���Ϥ��� data �������Ϥ��� lua_dump ���饤������Ƥ֡�

�饤�����ϥ��顼�����ɤ��֤��� 0�ϥ��顼�ʤ����̣���롣 ����ʳ����ͤϥ��顼���̣���� lua_dump �ˤ���ʾ�饤������Ƥ֤Τ��ᤵ���롣


lua_xmove

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

Ʊ�� �������Х륹�ơ��Ȥΰۤʤ륹��åɴ֤��ͤ�򴹤��롣

���δؿ��� from �Υ����å����� n �Ĥ��ͤ���Ф��� ������ to �Υ����å����Ѥࡣ


lua_yield

          int lua_yield  (lua_State *L, int nresults);

���롼��������Ǥ��롣

���δؿ��ϰʲ��Τ褦��C�δؿ���return���Ǥ����Ƥ٤롣

       return lua_yield (L, nresults);
C�δؿ���������ˡ�� lua_yield ��Ƥ֤ȥ��롼����μ¹Ԥ����Ǥ��졢 ���Υ��롼����򳫻Ϥ��� lua_resume �θƤӽФ�������롣 ���� nresults �� lua_resume �����֤����������å�����ͤο��Ǥ��롣

3.8 - �ǥХå����󥿥ե�����

Lua���Ȥ߹��ߤΥǥХå���ǽ����äƤ��ʤ��� ����ˡ����Τ���δؿ��� �եå� �ˤ���ü�ʥ��󥿥ե��������󶡤��Ƥ��롣 ���Υ��󥿥ե������ǡ��͡��ʼ���ΥǥХå����ץ��ե����顢����ӥ��󥿥ץ꥿�Ρ���������פ�ɬ�פȤ��뤽��¾�Υġ�������褦�ˤʤäƤ��롣


lua_Debug

          typedef struct lua_Debug {
            int event;
            const char *name;           /* (n) */
            const char *namewhat;       /* (n) */
            const char *what;           /* (S) */
            const char *source;         /* (S) */
            int currentline;            /* (l) */
            int nups;                   /* (u) ����ͤο� */
            int linedefined;            /* (S) */
            int lastlinedefined;        /* (S) */
            char short_src[LUA_IDSIZE]; /* (S) */
            /* private part */
            ...
          } lua_Debug;

�����ƥ��֤ʴؿ��˴ؤ��뿧���ʾ�����Ǽ����Τ˻Ȥ���¤�Ρ� lua_getstack �ϸ�ǻȤ�����ˡ����ι�¤�Τ������ѥ��Ф��������롣 lua_Debug ��¾�Υե�����ɤ����Ω�ľ��������ˤϡ�lua_getinfo ��Ƥ֡�

lua_Debug �γƥե�����ɤϰʲ��Τ褦�ʰ�̣����äƤ��롣


lua_gethook

          lua_Hook lua_gethook (lua_State *L);

���ߤΥեå��ؿ����֤���


lua_gethookcount

          int lua_gethookcount (lua_State *L);

���ߤΥեå�������Ȥ��֤���


lua_gethookmask

          int lua_gethookmask (lua_State *L);

���ߤΥեå��ޥ������֤���


lua_getinfo

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

lua_Debug �γƥե�����ɤ����Ω�ľ�������롣

���顼 (�㤨�� what �������ʤ���ꤷ���Ȥ�) �ΤȤ���0���֤��� ʸ���� what �γ�ʸ���ϡ���¤�� ar �ΤɤΥե�����ɤ����뤫�����򤹤롣 ����� lua_Debug ������dz����˽񤫤줿ʸ���ǻؼ����롣 `S�� �ϥե������ source, linedefined, lastlinedefined, what ����ᡢ `l�� �ϥե������ currentline ����ᡢ�ʲ�Ʊ�͡� ����ˡ�`f�� ����ꤹ��ȡ����ꤵ�줿��٥�����äƤ���ؿ��򥹥��å����Ѥࡣ

�����ƥ��֤Ǥʤ� (�����å���ˤʤ�) �ؿ��ξ��������ˤϡ� ����򥹥��å����Ѥ�� what ��ʸ�� '>' �ǻϤޤ�ʸ����ˤ��롣 �㤨�С��ؿ� f ��������줿���ֹ���Τꤿ�����ϡ����Τ褦�˽񤯡�

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


lua_getlocal

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

���ꤷ�������ƥ��١������쥳���ɤΥ��������ѿ��ˤĤ��Ƥξ�������롣 ���� ar �ˤϡ������� lua_getstack ��Ƥ�����뤫���եå� (lua_Hook �򻲾�) ���Ϥ��줿������Ȥ������ơ�ͭ���ʥ����ƥ��١������쥳���ɤ�Ϳ���ʤ���Фʤ�ʤ��� ����ǥå��� n ��Ĵ�٤���������ѿ�����ꤹ�� (1���ǽ�ΰ������ǽ�Υ����ƥ��֤ʥ��������ѿ��ǡ��Ǹ�Υ����ƥ��֤ʥ��������ѿ��ޤǤ���)�� lua_getlocal �Ϥ����ѿ����ͤ򥹥��å����Ѥߡ�����̾�����֤���

`(�� (�������) �ǻϤޤ��ѿ�̾�������ѿ���ɽ���Ƥ��� (�롼�������ѿ����ƥ�ݥ���ѿ���C�δؿ��Υ��������ѿ��ʤ�)��

����ǥå����������ƥ��֤ʥ��������ѿ��ο�����礭���Ȥ��ϡ�(�����Ѥޤ���) NULL ���֤���


lua_getstack

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

���󥿥ץ꥿��󥿥��ॹ���å��˴ؤ�������������롣

���δؿ��� lua_Debug �ΰ����� ���ꤷ����٥�Ǽ¹���δؿ��� �����ƥ��١������쥳���� �����롣 ��٥�0�ϸ������äƤ���ؿ��ǡ���٥� n+1 �ϥ�٥� n �θƤӽФ����δؿ��Ǥ��롣 ���顼���ʤ���� lua_getstack ��1���֤��� �����å��ο��������礭����٥뤬���ꤵ�줿����0���֤���


lua_getupvalue

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

����������ξ���ͤ˴ؤ�������������롣 (Lua�δؿ��ξ���ͤϡ����δؿ����ȤäƤ��볰�����������ѿ��ǡ�����������˼����ޤ줿��Ρ�) lua_getupvalue �ϥ���ǥå��� n �ξ���ͤ�������������ͤ򥹥��å����Ѥߡ�����̾�����֤��� funcindex �ϥ����å���Τ��Υ����������ؤ��� (����ͤϴؿ����Τ��Ϥä�ͭ���Ǥ��ꡢ����ν��������ʤ������Τ�������ν�����ֹ��դ����Ƥ��롣)

����ǥå���������ͤο�����礭�����ϡ�(�����Ѥޤ���) NULL ���֤��� C�δؿ��Ǥϡ��ɤξ���ͤ��Ф��Ƥ⤽��̾���˶�ʸ���� "" ���֤���


lua_Hook

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

�ǥХå��եå��ؿ��η���

�եå����ƤФ줿�Ȥ���ar ������ event �ե�����ɤ� �եå���ư�������٥�Ȥ���Ǽ����Ƥ��롣 Lua�Ϥ����Υ��٥�Ȥ�ʲ�������Ǽ��̤��롣 LUA_HOOKCALL, LUA_HOOKRET, LUA_HOOKTAILRET, LUA_HOOKLINE, LUA_HOOKCOUNT�� �����line���٥�ȤǤϡ��ե������ currentline �����ꤵ��롣 ar ��¾�Υե�����ɤ�����ˤϡ� lua_getinfo ��Ƥ�ɬ�פ����롣 return���٥�ȤǤϡ�event ���̾�� LUA_HOOKRET ��¾�� LUA_HOOKTAILRET �����ꤵ����礬���롣 ��Ԥ�Lua����ü�ƤӽФ������ؿ�����������򥷥ߥ�졼�Ȥ�����Τǡ� ���ξ�� lua_getinfo �����Ω���ʤ���

Lua���եå���¹Ԥ��Ƥ���֡�¾�Υեå��ƤӽФ��ϸ������ˤʤ롣 ���äơ��եå����Lua�δؿ������󥯤�ƤӽФ�����硢�եå���ƤФ��˼¹Ԥ���롣


lua_sethook

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

�ǥХå��եå��ؿ������ꤹ�롣

func �ϥեå��ؿ�����ꤹ�롣 mask �ϤɤΥ��٥�Ȥǥեå����ƤФ�뤫����� LUA_MASKCALL, LUA_MASKRET, LUA_MASKLINE, LUA_MASKCOUNT �������¤ǻ��ꤹ�롣 count ������mask�� LUA_MASKCOUNT ��ޤ�Ȥ�������̣����ġ� ���줾��Υ��٥�ȤˤĤ��ưʲ��ξ����ǥեå����ƤФ�롣

mask �˥��������ꤹ��Хեå���̵���ˤʤ롣


lua_setlocal

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

���ꤷ�������ƥ��١������쥳���ɤΥ��������ѿ����ͤ����ꤹ�롣 ���� ar ����� n �� lua_getlocal ��Ʊ���Ǥ��� (lua_getlocal �򻲾�)�� ���δؿ���lua_setlocal �ϥ����å��ȥåפ��ͤ򤽤��ѿ��˳�Ǽ��������̾�����֤��� �ޤ������ͤ򥹥��å������������

����ǥå����������ƥ��֤ʥ��������ѿ��ο������礭����С�(�������������) NULL ���֤���


lua_setupvalue

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

����������ξ���ͤ��ͤ����ꤹ�롣 ���� funcindex ����� n �� lua_getupvalue ��Ʊ���Ǥ��� (lua_getupvalue �򻲾�)�� ���δؿ��ϥ����å��ȥåפ��ͤ򤽤ξ���ͤ˳�Ǽ��������̾�����֤��� �ޤ������ͤ򥹥��å������������

����ǥå���������ͤο������礭����С�(�������������) NULL ���֤���

4 - ����饤�֥��

����饤�֥�� ��C��Lua�Υ��󥿥ե������Ȥʤ뤤���Ĥ��������ʴؿ����󶡤��롣 ����API��C��Lua�����äδ���Ū�ʴؿ����󶡤��뤬������饤�֥��Ϥ����Ĥ��ζ��̤κ�Ȥ򤹤���٥�ʴؿ����󶡤��롣

����饤�֥��Τ��٤Ƥδؿ��ϥإå����ե����� lauxlib.h ��������졢��Ƭ�� luaL_ ���դ��Ƥ��롣

����饤�֥��Τ��٤Ƥδؿ��ϴ���API�ξ�˹��ۤ���Ƥ��ꡢ���Τ��ᤳ��API�ǤǤ��ʤ����Ȥϲ����󶡤��Ƥ��ʤ���

����饤�֥��ˤ�C�δؿ��ΰ���������å����뤿��δؿ��������Ĥ����롣 �����Ͼ�� luaL_check* �ޤ��� luaL_opt* �Ȥ���̾���Ǥ��롣 �����δؿ��ϥ����å�������(satisfied?)�Ǥʤ��ä��Ȥ����顼���������롣 ���顼��å������ϰ����ǽ񼰲������ ("bad argument #1" �ʤ�) ���ᡢ ¾�Υ����å��ͤ��Ф��Ƥ����δؿ���Ȥ��٤��ǤϤʤ���

4.1 - �ؿ��ȷ�

����饤�֥��Τ��٤Ƥδؿ��ȷ��򥢥�ե��٥åȽ�˼�����


luaL_addchar

          void luaL_addchar (luaL_Buffer B, char c);

ʸ�� c ��Хåե� B ���ɲä��� (luaL_Buffer �򻲾�)��


luaL_addlstring

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

s ���ؤ�Ĺ�� l ��ʸ�����Хåե� B ���ɲä��롣 (luaL_Buffer �򻲾�)�� ʸ����������ޤ줿������ޤ�Ǥ��Ƥ��ɤ���


luaL_addsize

          void luaL_addsize (luaL_Buffer B, size_t n);

�Хåե����ꥢ (luaL_prepbuffer �򻲾�) �����󥳥ԡ����줿Ĺ�� n ��ʸ�����Хåե� B ���ɲä��롣 (luaL_Buffer �򻲾�)��


luaL_addstring

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

s ���ؤ�������üʸ�����Хåե� B ���ɲä��� (luaL_Buffer �򻲾�)�� ʸ����������ޤ줿������ޤळ�ȤϤǤ��ʤ���


luaL_addvalue

          void luaL_addvalue (luaL_Buffer *B);

�����å��ȥåפ��ͤ�Хåե� B ���ɲä��� (luaL_Buffer �򻲾�)�� �����ͤϥ����å������������롣

����ϥХåե����ɲä����ͤ򥹥��å�������ͣ���ʸ����Хåե��Ѵؿ��Ǥ��롣


luaL_argcheck

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

cond �����Ǥ��뤳�Ȥ��ǧ���롣 �⤷��ä��顢��å����� "bad argument #<numarg> to <func> (<extramsg>)" �Υ��顼���������롣 ������ func �ϥ����륹���å�����������롣


luaL_argerror

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

��å����� "bad argument #<numarg> to <func> (<extramsg>)" �Υ��顼���������롣 ������ func �ϥ����륹���å�����������롣

���δؿ��Ϸ褷�����ʤ����� C�δؿ��� return luaL_argerror ... �Ȥ��ƻȤ��Τ������Ǥ��롣


luaL_Buffer

          typedef struct luaL_Buffer luaL_Buffer;

ʸ����Хåե� �η���

ʸ����Хåե���C�Υ����ɤ�Lua��ʸ������(strings piecemeal)���Ȥ�Ω�Ƥ�Τ˻Ȥ��� ����ϰʲ��Τ褦�˻��Ѥ��롣

�̾�����򤷤Ƥ���֡� ʸ����Хåե��Ϥ����Ĥ��Υ����å������åȤ�Ȥ��� ���äƥХåե���ȤäƤ���֤ϡ������å��ȥåפ��ɤ��ˤ��뤫Ƚ�äƤ���Ȳ���Ǥ��ʤ��� �Хåե�����������(successive)�ƤӽФ��δ֡����礬���Ƥ���¤�ϥ����å���Ȥ����Ȥ��Ǥ��롣 �Ĥޤꡢ�Хåե�����ƤӽФ��Ȥ��ϡ� �����å�������Хåե�����ľ���Ʊ���⤵�Ǥʤ���Фʤ�ʤ��� (luaL_addvalue �Ϥ��Υ롼���ͣ����㳰�Ǥ��롣) luaL_pushresult ��Ƥ�����ȡ� �����å��ϥХåե����������������ι⤵����ꡢ���ξ�˺ǽ�Ū��ʸ�����Ѥޤ�롣


luaL_buffinit

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

�Хåե� B ���������롣 ���δؿ��Ϥ����ʤ���֤������Ƥʤ��� �Хåե����ѿ��Ȥ���������ʤ���Фʤ�ʤ� (luaL_Buffer �򻲾�)��


luaL_callmeta

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

�᥿�᥽�åɤ�Ƥ֡�

����ǥå��� obj �Υ��֥������Ȥ��᥿�ơ��֥����äƤ��ơ� ���Υ᥿�ơ��֥뤬�ե������ e ����äƤ���С� ���δؿ��Ϥ��Υե�����ɤ�ƤӽФ��������Ȥ��Ƥ��Υ��֥������Ȥ��Ϥ��� ���ξ�硢���δؿ���1���֤����ƤӽФ�������ͤ򥹥��å����Ѥࡣ �᥿�ơ��֥뤬�ʤ����᥿�᥽�åɤ��ʤ���硢 ���δؿ��� (�����å��˲����Ѥޤ���) 0���֤���


luaL_checkany

          void luaL_checkany (lua_State *L, int narg);

�ؿ������� arg ��Ǥ�դη� (nil ��ޤ�) �ΰ�������Ĥ������å����롣


luaL_checkint

          int luaL_checkint (lua_State *L, int narg);

�ؿ����� narg ���������ͤǤ��뤫������å����� �����ͤ� int �˥��㥹�Ȥ����֤���


luaL_checkinteger

          lua_Integer luaL_checkinteger (lua_State *L, int narg);

�ؿ����� narg ���������ͤǤ��뤫������å����� �����ͤ� lua_Integer �˥��㥹�Ȥ����֤���


luaL_checklong

          long luaL_checklong (lua_State *L, int narg);

�ؿ����� narg ���������ͤǤ��뤫������å����� �����ͤ� long �˥��㥹�Ȥ����֤���


luaL_checklstring

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

�ؿ����� narg ������ʸ����Ǥ��뤫������å���������ʸ������֤��� l �� NULL �Ǥʤ���С� *l ��ʸ�����Ĺ�����Ǽ���롣


luaL_checknumber

          lua_Number luaL_checknumber (lua_State *L, int narg);

�ؿ����� narg ���������ͤǤ��뤫������å����� ���ο��ͤ��֤���


luaL_checkoption

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

�ؿ����� narg ������ʸ����Ǥ��뤫�����å����� ���� lst (NULL��ü�Ǥʤ���Фʤ�ʤ�) ���餽��ʸ����򸡺����롣 def �� NULL �Ǥʤ���С� �ؿ����� narg ����������ʤ������ΰ����� nil �Ǥ��ä����Υǥե�����ͤȤ��ƻȤ���

ʸ���󤬸��Ĥ��ä����󥤥�ǥå������֤��� ������ʸ����Ǥʤ���ʸ���󤬸��Ĥ���ʤ���Х��顼��ȯ�����롣

���δؿ���ʸ�����C����󷿤��Ѵ�����Τ����Ω�ġ� Lua�Υ饤�֥��ˤ������̾�δ���Ǥϡ����ץ��������򤹤�Τˡ����ͤǤʤ�ʸ�����Ȥ���


luaL_checkstack

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

�����å��������� top + sz �Ĥ����Ǥ˿��Ф��� �����å������Υ������˿��Ф��ʤ���Х��顼��ȯ�����롣 msg �Ϥ��Υ��顼��å�������������ɲä�ʸ����Ǥ��롣


luaL_checkstring

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

�ؿ����� narg ������ʸ����Ǥ��뤫�����å���������ʸ������֤���


luaL_checktype

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

�ؿ����� narg �������� t �Ǥ��뤫�����å����롣


luaL_checkudata

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

�ؿ����� narg �������� tname �Υ桼�����ǡ����Ǥ��뤫�����å����� (luaL_newmetatable �򻲾�)��


luaL_error

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

���顼��ȯ�������롣 ���顼��å������ν񼰤� fmt ���ɲäΰ�����Ϳ�����롣 ����� lua_pushfstring �Τ�Ʊ���롼��˽����� �ޤ�����å������κǽ�˥��顼��ȯ�������ե�����̾�ȹ��ֹ�򡢤����ξ������Ѳ�ǽ�ʤ�С��ɲä��롣

���δؿ��Ϸ褷�����ʤ����� C�δؿ��� return luaL_error ... �Τ褦�˻Ȥ��Τ�����Ǥ��롣


luaL_getmetafield

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

����ǥå��� obj �Υ��֥������ȤΥ᥿�ơ��֥�Υե������ e �򥹥��å����Ѥࡣ ���Υ��֥������Ȥ��᥿�ơ��֥����äƤ��ʤ������᥿�ơ��֥뤬���Υե�����ɤ���äƤ��ʤ���� 0 ���֤��Ʋ����Ѥޤʤ���


luaL_getmetatable

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

�쥸���ȥ��̾�� tname �˴�Ϣ�դ���줿�᥿�ơ��֥�򥹥��å����Ѥ� (luaL_newmetatable �򻲾�)��


luaL_gsub

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

ʸ���� s ���ʸ���� p �򤹤٤�ʸ���� r ���ִ��������ԡ����롣 ���η�̤�ʸ����򥹥��å����Ѥߡ�������֤���


luaL_loadbuffer

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

Lua�Υ���󥯤Ȥ��ƥХåե�������ɤ��롣 ���δؿ��� lua_load ��Ȥä� buff ���ؤ������� sz �ΥХåե��˳�Ǽ����Ƥ������󥯤�����ɤ��롣

���δؿ��� lua_load ��Ʊ����̤��֤��� name �ϥǥХå�����䥨�顼��å������ǻȤ������̾�Ǥ��롣


luaL_loadfile

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

Lua�Υ���󥯤Ȥ��ƥե����������ɤ��롣 ���δؿ��� lua_load ��Ȥä�̾�� filename �Υե�����˳�Ǽ����Ƥ������󥯤�����ɤ��롣 filename �� NULL �ξ���ɸ�����Ϥ����ɤ߹��ࡣ �ե����뤬 # �ǻϤޤäƤ����顢���κǽ�ιԤ�̵�뤹�롣

���δؿ��� lua_load ��Ʊ����̤��֤����� �ɲäΥ��顼�����ɤȤ��ƥե�����򳫤��ʤ��ä����ɤ�ʤ��ä����� LUA_ERRFILE ���֤���


luaL_loadstring

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

Lua�Υ���󥯤Ȥ���ʸ���������ɤ��롣 ���δؿ��� lua_load ��Ȥäƥ�����üʸ���� s �˳�Ǽ����Ƥ������󥯤�����ɤ��롣

���δؿ��� lua_load ��Ʊ����̤��֤���


luaL_newmetatable

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

�쥸���ȥ�˥��� tname �����Ǥˤ���� 0 ���֤��� �����Ǥʤ���С��桼�����ǡ����Υ᥿�ơ��֥�Ȥ��ƻȤ��������ơ��֥���ꡢ �����쥸���ȥ�˥��� tname �ȶ����ɲä��� 1 ���֤���

�ɤ���ξ���쥸���ȥ�� tname �˴�Ϣ�դ���줿�ǽ�Ū���ͤ򥹥��å����Ѥࡣ


luaL_newstate

          lua_State *luaL_newstate (void);

ɸ���C�� realloc �ؿ���١����ˤ��������������ؿ���Ȥä� lua_newstate ��Ƥӡ�������Lua���ơ��Ȥ�������롣 �ޤ�����̿Ū���顼�ξ���ɸ�२�顼���Ϥ˥��顼��å���������Ϥ���ѥ˥å��ؿ� (lua_atpanic �򻲾�) �����ꤹ�롣

���������ơ��Ȥ��֤��� ������ݥ��顼�ξ��� NULL ���֤���


luaL_openlibs

          void luaL_openlibs (lua_State *L);

���ꤷ�����ơ��Ȥˤ��٤Ƥ�ɸ��Lua�饤�֥��򳫤���


luaL_optint

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

�ؿ����� narg ���������ͤǤ���С����ο��ͤ� int �˥��㥹�Ȥ����֤��� ���ΰ�����¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣


luaL_optinteger

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

�ؿ����� narg ���������ͤǤ���С� ���ο��ͤ� lua_Integer �˥��㥹�Ȥ����֤��� ���ΰ�����¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣


luaL_optlong

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

�ؿ����� narg ���������ͤǤ���С����ο��ͤ� long �˥��㥹�Ȥ����֤��� ���ΰ�����¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣


luaL_optlstring

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

�ؿ����� narg ������ʸ����Ǥ���С�����ʸ������֤��� ������¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣

l �� NULL �Ǥʤ���С���̤�Ĺ���� *l �˳�Ǽ���롣


luaL_optnumber

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

�ؿ����� narg ���������ͤǤ���С����ο��ͤ��֤��� ���ΰ�����¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣


luaL_optstring

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

�ؿ����� narg ������ʸ����Ǥ���С�����ʸ������֤��� ���ΰ�����¸�ߤ��ʤ��� nil �Ǥ���С�d ���֤��� ����ʤ��Х��顼��ȯ�����롣


luaL_prepbuffer

          char *luaL_prepbuffer (luaL_Buffer *B);

�Хåե� B ���ɲä��뤿���ʸ������Ǽ�Ǥ��롢 ������ LUAL_BUFFERSIZE ���ΰ�Υ��ɥ쥹���֤� (luaL_Buffer �򻲾�)�� ʸ����򤳤��ΰ�˳�Ǽ�������ȡ�ʸ����Υ��������Ϥ��� luaL_addsize ��Ƥӡ��ºݤ˥Хåե����ɲä��ʤ���Фʤ�ʤ���


luaL_pushresult

          void luaL_pushresult (luaL_Buffer *B);

�����å��ȥåפ˺ǽ�Ū��ʸ�����Ĥ��ƥХåե� B �λ��Ѥ򽪤��롣


luaL_ref

          int luaL_ref (lua_State *L, int t);

����ǥå��� t �Υơ��֥�˥����å��ȥåפΥ��֥������Ȥ��Ф��� ��ե���� ���������������֤�(�����ƥ��֥������Ȥ򥹥��å����������)��

��ե���󥹤ϰ�դ������Υ����Ǥ��롣 �ơ��֥� t �������������ư���ɲä��ʤ���С� luaL_ref ���֤������ΰ�������ݾڤ��롣 lua_rawgeti(L, t, r) ��Ƥ֤ȡ���ե���� r �����Ȥ��륪�֥������Ȥ�����Ǥ��롣 luaL_unref �ϥ�ե���󥹤Ȥ���˴�Ϣ�դ���줿���֥������Ȥ�������롣

�����å��ȥåפΥ��֥������Ȥ� nil �ξ�硢 luaL_ref ����� LUA_REFNIL ���֤��� ��� LUA_NOREF �� luaL_ref ���֤������ʤ��ե���󥹤Ȥ�ۤʤ뤳�Ȥ��ݾڤ���Ƥ��롣


luaL_Reg

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

luaL_register ����Ͽ����ؿ�������η��� name �ϴؿ���̾���ǡ�func �ϴؿ��ؤΥݥ��󥿤Ǥ��롣 luaL_Reg ������� name �� func ������ NULL �Ǥ�����ʼ����ȥ�ǽ����ʤ���Фʤ�ʤ���


luaL_register

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

�饤�֥��򳫤���

libname �� NULL ���Ϥ��ƸƤ֤ȡ� ñ��˥ꥹ�� l (luaL_Reg �򻲾�) �δؿ��򤹤٤ƥ����å��ȥåפΥơ��֥����Ͽ���롣

libname ��NULL�Ǥʤ���С� �������ơ��֥� t ��������� ����򥰥����Х��ѿ� libname ���ͤȤ������ꤷ�� package.loaded[libname] ���ͤȤ������ꤷ�� �����ƥꥹ�� l �δؿ��򤹤٤Ƥ�������Ͽ���롣 �⤷ package.loaded[libname] ���ѿ� libname �˥ơ��֥뤬¸�ߤ���С� �������ơ��֥��������ˤ��������Ѥ��롣

������ξ��⡢���δؿ��ϥ����å��ȥåפˤ��Υơ��֥���֤���


luaL_typename

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

����ǥå��� idx ���ͤη���̾�����֤���


luaL_typerror

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

<location>: bad argument <narg> to <function> (<tname> expected, got <realt>)
�Τ褦�ʥ�å������Υ��顼���������롣 ������ <location> �� luaL_where �ˤ�ä��������줿��Τǡ� <function> �ϸ��ߤδؿ���̾���� and <realt> �ϼ°����η�̾�Ǥ��롣


luaL_unref

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

����ǥå��� t �Υơ��֥뤫���ե���� ref ��������� (luaL_ref �򻲾�)�� ����ȥ꤬�ơ��֥뤫����������Τǡ����Ȥ���Ƥ������֥������Ȥϲ���������롣 ��ե���� ref ������Ѥ��뤿��˲�������롣

ref �� LUA_NOREF �ޤ��� LUA_REFNIL �ξ�硢 luaL_unref �ϲ��⤷�ʤ���


luaL_where

          void luaL_where (lua_State *L, int lvl);

�����륹���å��Υ�٥� lvl ������θ��߰��֤��̤���ʸ����򥹥��å����Ѥࡣ ŵ��Ū�ˤ���ʸ����� <chunkname>:<currentline>: �Τ褦�ʽ񼰤ˤʤäƤ��롣 ��٥�0�ϼ¹���δؿ��� ��٥�1�ϼ¹���δؿ��θƤӽФ����δؿ��� �ʲ�Ʊ�ͤǤ��롣

���δؿ��ϥ��顼��å���������Ƭ�����ۤ��뤿��˻Ȥ���

5 - ɸ��饤�֥��

Luaɸ��饤�֥��ϡ�C��API��Ȥä�ľ�ܼ������줿�����ʴؿ����󶡤��롣 �����Ĥ��ϸ�����ܼ�Ū�ʥ����ӥ����󶡤����ΤǤ��� (�㤨�� type �� getmetatable)�� �Ĥ�ϡֳ����Ρץ����ӥ��ؤΥ����������󶡤����ΤǤ��� (�㤨�� I/O)�� �ޤ���Lua���ȤǼ�����ǽ�Ǥ��뤬����������ѥե����ޥ��׵�Τ����C�Ǽ������줿��Τ⤢�� (�㤨�� sort)��

���٤ƤΥ饤�֥��ϸ�������Ƥ���C��API��ȤäƼ�������Ƥ��ꡢ��Ω����C�Υ⥸�塼����󶡤���Ƥ��롣 ���ߡ�Lua�ˤϰʲ���ɸ��饤�֥�꤬���롣

���ܥ饤�֥��ȥѥå������饤�֥��ʳ��ϡ� ���줾��Υ饤�֥�꤬�� �������Х�ơ��֥�Υե�����ɤ������Υ��֥������ȤΥ᥽�åɤȤ��ơ����Τ��٤Ƥδؿ����󶡤��Ƥ��롣

�����Υ饤�֥���Ȥ��ˤϡ�C�Υۥ��ȥץ������� ���٤Ƥ�ɸ��饤�֥��򳫤� luaL_openlibs ��ƤФʤ���Фʤ�ʤ��� ����ˡ� luaopen_base (���ܥ饤�֥����)�� luaopen_package (�ѥå������饤�֥����)�� luaopen_string (ʸ����饤�֥����)�� luaopen_table (�ơ��֥�饤�֥����)�� luaopen_math (���إ饤�֥����)�� luaopen_io (I/O�饤�֥���OS�饤�֥����)�� luaopen_debug (�ǥХå��饤�֥����) ��Ƥ�Ǹ��̤˳������Ȥ�Ǥ��롣 ������ lualib.h ���������Ƥ��뤬�� ľ�ܸƤ֤٤��ǤϤʤ���¾��Lua��C�ؿ���Ʊ�ͤ� ---- �㤨�� lua_call ��Ȥä� ---- �ƤФʤ���Фʤ�ʤ���

5.1 - ���ܴؿ�

���ܥ饤�֥���Lua�ؤΥ����ʵ�ǽ���󶡤��롣 ���ץꥱ�������ˤ��Υ饤�֥���ޤ�ʤ����ϡ����ε�ǽ���󶡤�������μ������Ѱդ���ɬ�פ����뤫���Ť�Ĵ�٤�٤��Ǥ��롣


assert (v [, message])

���� v ���� (���ʤ�� nil �ޤ��� false) �Ǥ���Х��顼��ȯ�������롣 �����Ǥʤ���С����Τ��٤Ƥΰ������֤��� message �ϥ��顼��å���������ꤹ�롣 ��ά���줿���� "assertion failed!" �Ǥ��롣


collectgarbage (opt [, arg])

���δؿ��ϥ��١������쥯���ؤ����ѥ��󥿥ե������Ǥ��롣 �ǽ�ΰ��� opt �ˤ�äưۤʤ뵡ǽ��¹Ԥ��롣


dofile (filename)

�ե�����򳫤����������Ƥ�Lua����󥯤Ȥ��Ƽ¹Ԥ��롣 ���������ꤵ��ʤ���С�ɸ������ (stdin) �����ɤ߼�äƼ¹Ԥ��롣 dofile�ϥ���󥯤����֤��줿���٤Ƥ��ͤ򤽤Τޤ��֤��� ���顼�����������ϡ��ƤӽФ�¦�����¤���� (�Ĥޤ� dofile ���ݸ�⡼�ɤ�ư���ΤǤϤʤ�)��


error (message [, level])

�Ǹ���ݸ�줿�ؿ��ƤӽФ���λ����message �򥨥顼��å������Ȥ����֤��� �ؿ� error �����ʤ���

�̾error �ϥ�å���������Ƭ�˥��顼�ΰ��֤˴ؤ��벿�餫�ξ�����ɲä��롣 level �����ϡ����顼��å����������顼���֤�ɤΤ褦�����뤫����ꤹ�롣 ��٥�1�Ǥ� (�ǥե����)��error �ؿ���Ƥ����꤬���顼���֤Ǥ��롣 ��٥�2�� error ��Ƥ���ؿ���Ƥ�����֤�ؤ��� �ʲ�Ʊ�ͤǤ��롣 ��٥�0���Ϥ��ȥ�å������˥��顼���־�����ɲä��ʤ���


_G

�������Х�Ķ����ݻ����륰�����Х��ѿ��Ǥ��� (�ؿ��ǤϤʤ�)�� �Ĥޤꡢ_G._G = _G �Ǥ��롣 Lua���ȤϤ����ѿ�����Ѥ��ʤ��Τǡ������ͤ��ѹ����Ƥ�Ķ��ˤϲ��αƶ���ʤ����դ�ޤ�Ʊ���Ǥ��� (�Ķ����Ѥ���ˤ� setfenv ��Ȥ�)��


getfenv (f)

�ؿ��θ��ߤδĶ����֤��� f ��Lua�δؿ������ؿ��Υ����å���٥�򼨤����ͤǤ��롣 ��٥�1��getfenv��Ƥ���ؿ��Ǥ��롣 �⤷Ϳ����줿�ؿ���Lua�δؿ��Ǥʤ��ä��ꡢf��0�ξ��ϡ�getfenv �ϥ������Х�Ķ����֤��� f �Υǥե�����ͤ�1�Ǥ��롣


getmetatable (object)

�⤷ object ���᥿�ơ��֥����äƤ��ʤ���� nil ���֤��� �⤷object�Υ᥿�ơ��֥뤬 "__metatable" �ե�����ɤ���äƤ���С������ͤ��֤��� �����Ǥʤ����object�Υ᥿�ơ��֥���֤���


ipairs (t)

3�Ĥ��͡����ƥ졼���ؿ����ơ��֥� t�������0���֤���

       for i,v in ipairs(t) do ... end
�� (1,t[1])��(2,t[2])���ĤΥڥ��򡢺ǽ���ͤ�nil�������ޤǷ����֤���

�����˥ơ��֥���ѹ�����ݤ����դ� next �򻲾ȡ�


load (func [, chunkname])

���Υԡ������������ؿ� func ��Ȥäƥ���󥯤�����ɤ��롣 func �����������ͤ�Ϣ�뤹��ʸ������֤��ʤ���Фʤ�ʤ��� nil ���֤� (�ޤ�������ͤʤ�) �ȥ���󥯤ν������Τ餻�롣

���顼���ʤ���С�����ѥ��뤵�줿����󥯤��ؿ��Ȥ����֤��졢 �����Ǥʤ���� nil �ȥ��顼��å��������֤���롣 �֤��줿�ؿ��δĶ��ϥ������Х�Ķ��Ǥ��롣

chunkname �ϥ��顼��å�������ǥХå�����Τ���Υ����̾����ꤹ�롣


loadfile ([filename])

load ��Ʊ���Ǥ��뤬�� �ե����� filename �������󥯤��ɤ߹��ࡣ �ե�����̾��Ϳ���ʤ����ɸ�����Ϥ����ɤ߹��ࡣ


loadstring (string [, chunkname])

load ��Ʊ���Ǥ��뤬�� ���ꤷ��ʸ���󤫤����󥯤��ɤ߹��ࡣ

Ϳ����줿ʸ���������ɤ��Ƽ¹Ԥ���ˤϡ��ʲ��δ��Ѷ��Ȥ���

      assert(loadstring(s))()


next (table [, index])

�ơ��֥�����ե�����ɤ��󤹤뤿��δؿ��Ǥ��롣 �ǽ�ΰ����ϥơ��֥�������ܤΰ����Ϥ��Υơ��֥�Υ���ǥå������Ϥ��� next �ϥơ��֥���μ��Υ���ǥå����ȡ������ͤ��֤��� �����ܤΰ����� nil ���Ϥ��ȡ��������ǥå����Ȥ����ͤ��֤���롣 �Ǹ�Υ���ǥå����ǸƤӽФ��������Υơ��֥���Ф��� nil �ǸƤӽФ��ȡ� next �� nil ���֤��� �����ܤΰ�������ά���줿���� nil �Ȳ�ᤵ��롣 �äˡ�next(t) ��Ȥ��ȥơ��֥뤬�����ɤ���Ĵ�٤뤳�Ȥ��Ǥ��롣

Lua�ˤϥե�����ɤ�������ʤ��� �ơ��֥���˥ե�����ɤ�¸�ߤ��ʤ��Τȡ�nil �ͤ���Ǽ���줿�ե�����ɤˤϡ����ΰ㤤��̵���� �椨�ˡ�next �� nil �Ǥʤ��ͤ���ĥե�����ɤΤߤ��θ���롣 ����ǥå�������󤵤����֤ϡ����ͤΥ���ǥå������Ф��Ƥ�������Ǥ��� (���ͽ�˥ơ��֥���󤹤�ˤϡ������Ѥ� for ʸ�� ipairs �ؿ���Ȥ�)��

�ơ��֥�ν����ˡ��⤷¸�ߤ��Ƥ��ʤ��ե�����ɤ˿������ͤ�������Ƥ�줿�顢next ��ư��� ̤��� �Ǥ��롣 ��������¸�Υե�����ɤ��ѹ����Ƥ�褤�� �äˡ���¸�Υե�����ɤ�õ��ΤϹ���ʤ���


pairs (t)

3�Ĥ��͡�next �ؿ����ơ��֥� t��nil ���֤���

       for k,v in pairs(t) do ... end
�ϥơ��֥� t �Τ��٤ƤΥ������ͥڥ��ˤĤ��Ʒ����֤���

�����˥ơ��֥���ѹ�����ݤ����դ� next �򻲾ȡ� +


pcall (f, arg1, arg2, ...)

�ݸ�⡼�ɤǡ�Ϳ����줿������ f ��ƤӽФ��� �Ĥޤ� f ��������ȯ���������顼�����¤��줺�� ����� pcall �����顼����館�����ơ����������ɤ��֤��� �ǽ�ΰ����ϥ��ơ����������� (�֡��ꥢ��) �ǡ����顼�ʤ��˸ƤӽФ������������Ȥ��Ͽ����֤��� ���ξ�硢f ������ͤ⤹�٤ơ��ǽ������ͤ�³�����֤���롣 ���顼�������ä���硢pcall �� false �ȥ��顼��å��������֤���


print (e1, e2, ...)

�����򤤤��ĤǤ��뤳�Ȥ��Ǥ����������ͤ� tostring ��ʸ������Ѵ����Ƥ���ɸ����� (stdout) ��ɽ�����롣 print �Ͻ񼰲����Ϥ�տޤ�����ΤǤϤʤ��� ŵ��Ū�ˤϥǥХå��Τ���ˡ��ͤ�ɽ�������ñ����ˡ�Ȥ����Ѱդ���Ƥ�������Ǥ��롣 �񼰲����Ϥˤ� string.format ��Ȥ���


rawequal (v1, v2)

�᥿�᥽�åɤ�Ƥ֤��Ȥʤ��� v1 �� v2 �����������ɤ���Ĵ�٤롣 �֡��ꥢ����֤���


rawget (table, index)

�᥿�᥽�åɤ�Ƥ֤��Ȥʤ��� table[index] ���������ͤ����롣 table �ϥơ��֥�Ǥʤ���Фʤ�ʤ��� index �� nil �ʳ��Τɤ���ͤǤ��ɤ���


rawset (table, index, value)

�᥿�᥽�åɤ�Ƥ֤��Ȥʤ��� table[index] �� value �򥻥åȤ��롣 table �ϥơ��֥�Ǥʤ���Фʤ�ʤ��� index �� nil �ʳ��Τɤ���ͤǤ��ɤ��� value �Ϥɤ��Lua���ͤǤ��ɤ���


select (index, ...)

index �����ͤǤ���С� index ���ܰʹߤΰ����򤹤٤��֤��� �����Ǥʤ���С�index ��ʸ���� "#" �Ǥʤ���Фʤ�ʤ��� ���ξ�� select �ϼ�����ä�;ʬ�ΰ����ι�׿����֤���


setfenv (f, table)

���ꤵ�줿�ؿ��ǻȤ���Ķ����ѹ����롣 f ��Lua�δؿ������ؿ��Υ����å���٥����ꤹ����ͤǤ��롣 ��٥�1�� setfenv ��ƤӽФ����ؿ��򼨤��� setfenv ��Ϳ����줿�ؿ����֤���

�ü�ʥ������Ȥ��ơ�f��0��Ϳ������ȡ�setfenv ��������Υ���åɤδĶ����Ѥ��롣 ���ξ�硢setfenv �ϲ����֤��ʤ���


setmetatable (table, metatable)

table �Υ᥿�ơ��֥���ѹ����� (Lua����¾�η��Υ᥿�ơ��֥���ѹ����뤳�ȤϤǤ��ʤ���C����Τ߲�ǽ�Ǥ���)�� �⤷ metatable �� nil �Ǥ���С�table �Υ᥿�ơ��֥�Ͻ����롣 ���Υ᥿�ơ��֥뤬 "__metatable" �ե�����ɤ���äƤ���ȡ����顼��ȯ���롣

���δؿ��� table ���֤���


tonumber (e [, base])

��������ͤ��Ѵ����褦�Ȥ��롣 �⤷���������Ǥ˿��ͤ��ä��ꡢ���ͤ��Ѵ���ǽ��ʸ����Ǥ���С�tonumber �Ͽ��ͤ��֤��� �����Ǥʤ���� nil ���֤���

��ά��ǽ�ʰ����Ͽ��ͤ��᤹��ݤδ������ꤹ�롣 �����2����36�����������Ǥ��롣 10����礭������Ǥϡ�`A����10��ɽ����`B����11��ɽ���� �ʲ�Ʊ�ͤ�³����`Z����35��ɽ�� (��ʸ���Ǥ⾮ʸ���Ǥ��ɤ�)�� �����10 (�ǥե����) �ξ�� �ϡ����ͤ˾�������ؿ������դ��뤳�Ȥ��Ǥ��� (2.1 �򻲾�)�� ¾�δ���Ǥϡ����ʤ��������Τߤ�����դ��롣


tostring (e)

Ǥ�դη��ΰ����������ꡢ���򤷤䤹��������ʸ������Ѵ����롣 ���ͤ��Ѵ��������ˡ�����˥���ȥ����뤹����� string.format ��Ȥ���

�⤷ e �Υ᥿�ơ��֥뤬 "__tostring" �ե�����ɤ���äƤ����顢 e ������ˡ����δ�Ϣ�դ���줿�ͤ��ƤӽФ��졢��������ͤ���̤Ȥ��ƻȤ��롣


type (v)

�ͤη���ʸ������֤��� ���δؿ����֤��ͤϰʲ��Τ����줫�Ǥ��롣
    "nil" (�Ȥ���ʸ����nil �ͤǤϤʤ���)
    "number"
    "string"
    "boolean"
    "table"
    "function"
    "thread"
    "userdata"


unpack (list [, i [, j]])

Ϳ����줿�ơ��֥�����Ǥ��֤��� ���δؿ��ϡ��ʲ��Υ����ɤˤϸ�������ǿ������񤱤ʤ����Ȥ�����ơ��ʲ��Υ����ɤ������Ǥ��롣
  return list[i], list[i+1], ..., list[j]
�ǥե���ȤǤϡ�i ��1�� j ��Ĺ���黻�� (2.5.5 �򻲾�) �������Ƥ���ꥹ�Ȥ�Ĺ���Ǥ��롣


_VERSION

���ߤΥ��󥿥ץ꥿�ΥС������ʸ������ݻ����Ƥ��륰�����Х��ѿ� (�ؿ��ǤϤʤ�)�� �����ѿ��θ��ߤ����Ƥ� "Lua 5.1" �Ǥ��롣


xpcall (f, err)

���δؿ��� pcall �˻��Ƥ��뤬�����顼�ϥ�ɥ�����Ǥ��������ۤʤ롣

xpcall ���ݸ�⡼�ɤ� f ��ƤӽФ��� err �򥨥顼�ϥ�ɥ�Ȥ��ƻȤ��� f ��������ȯ���������顼�����¤���ʤ��� ����ˡ�xpcall �����顼����館�����顼���֥������Ȥ������ err ��Ƥ֡� �ǽ������ͤϥ��ơ����������� (�֡��ꥢ��) �ǡ� ���顼�������ʤ��ä����� true ���֤��� ���ξ�硢�ǽ������ͤ�³���� f ������ͤ⤹�٤��֤���롣 ���顼����������硢xpcall �� false �� err ������ͤ��֤���

5.2 - ���롼�������

���롼�����Ϣ�����ϴ��ܥ饤�֥��Υ��֥饤�֥��Ǥ��ꡢ�ơ��֥� coroutine ����֤���Ƥ��롣 ���롼����˴ؤ������Ū�������� 2.11 �򻲾ȡ�


coroutine.create (f)

f �����ΤȤ��뿷�������롼������롣 f ��Lua�δؿ��Ǥʤ���Фʤ�ʤ��� "thread" ���ο��������롼���󥪥֥������Ȥ��֤���


coroutine.resume (co [, val1, ..., valn])

���롼���� co �μ¹Ԥ򳫻�/�Ƴ����롣 ���롼�����ǽ��resume�����Ȥ����������Τμ¹Ԥ����Ϥ���롣 �� val1, ... �����Τδؿ��˰����Ȥ����Ϥ���롣 ���롼�������Ǥ���Ƥ�����硢resume �Ϥ����Ƴ����� yield ���������ͤȤ��� val1, ... ���Ϥ���롣

���롼���󤬥��顼̵���¹Ԥ����С� resume �� true �˲ä��� yield ���Ϥ��줿�� (���롼�������Ǥ��줿���)�� �⤷�������Τδؿ������֤��줿�� (���롼���󤬽�λ�������) ���֤��� ���顼���������顢resume �� false �ȥ��顼��å��������֤���


coroutine.running ()

������Υ��롼������֤��� �ᥤ�󥹥�åɤǸƤФ줿���� nil ���֤���


coroutine.status (co)

���롼���� co �ξ��֤�ʸ������֤���

"running" ... ���롼����������档 "suspended" ... ���롼����� yield �θƤӽФ������Ǥ���Ƥ��뤬���ޤ��¹���Ǥ��롣 "normal" ... ���롼����ϥ����ƥ��֤Ǥ��뤬������Ǥʤ�(�Ĥޤ�¾�Υ��롼�����resume���Ƥ���)�� "dead" ... ���롼��������Τδؿ�����λ�����������顼����ߤ�����


coroutine.wrap (f)

f �����ΤȤ��뿷�������롼�����������롣 f ��Lua�δؿ��Ǥʤ���Фʤ�ʤ��� coroutine.wrap �ϡ��ƤФ�뤿�Ӥ˥��롼�����Ƴ�����ؿ����֤��� �ؿ����Ϥ��줿������ resume ��;ʬ���Ϥ���������Ʊ��ư��򤷡� ����ͤ� resume ����ǽ�Υ֡��ꥢ���������ͤ�Ʊ���Ǥ��롣 �⤷���顼����������硢���顼�����¤��롣


coroutine.yield ([val1, ..., valn])

�ƤФ줿���롼����μ¹Ԥ����Ǥ��롣 ���롼����ϡ�C�δؿ���᥿�᥽�åɡ����ƥ졼�������Ǥ��뤳�ȤϤǤ��ʤ��� yield ���Ϥ��줿������ resume �����ɲä�����ͤȤ����֤���롣

5.3 - �⥸�塼��

Lua�ǥ⥸�塼����ۤ���������ɤ����ꤹ�����Ū�ʵ�ǽ���󶡤��롣 2�Ĥδؿ� require ����� module �ϥ������Х�Ķ���ľ�ܥ������ݡ��Ȥ���롣 ����ʳ��Ϥ��٤ƥơ��֥� package �˥������ݡ��Ȥ���롣


module (name [, ...])

�⥸�塼���������롣 package.loaded[name] �˥ơ��֥뤬����С� ���Υơ��֥뤬�⥸�塼��Ǥ��롣 �����Ǥʤ���С����ꤷ��̾���Υ������Х�ʥơ��֥� t ������С� ���Υơ��֥뤬�⥸�塼��Ǥ��롣 �����Ǥʤ���С��������ơ��֥� t ��������� �������Х��ѿ� name ���ͤ� package.loaded[name] ���ͤˤ�������ꤹ�롣 �ޤ����δؿ��ϻ��ꤵ�줿̾���� t._NAME �� �⥸�塼�� (t ���켫��) �� t._M �� �ѥå�����̾ (�����ʥ⥸�塼��̾����Ǹ����ʬ���������Ρ���������) �� t_PACKAGE ���������롣 �Ǹ�ˡ�module �ϸ��ߤδؿ��ο������Ķ������ package.loaded[name] �ο������ͤȤ��� t �����ꤹ�롣 ���ä� require �� t ���֤���

�⤷ name ��ʣ��̾ (�Ĥޤꡢ�ɥåȤdz��������ڤ�줿���) �Ǥ���С� module �Ϥ��줾�����ʬ�ˤĤ��ƥơ��֥���� (�ޤ��ϡ����Ǥ�¸�ߤ���к����Ѥ���)�� �㤨�С�name �� a.b.c �ξ�硢 module �ϥ������Х��ѿ� a �Υե������ b �Υե������ c �˥⥸�塼��ơ��֥���Ǽ���롣

���δؿ��ϥ⥸�塼��̾�θ�˾�ά��ǽ�� ���ץ���� ���Ϥ����Ȥ��Ǥ��롣 ���γƥ��ץ����ϥ⥸�塼�����Τ�Ŭ�Ѥ����ؿ��Ǥ��롣


require (modname)

���ꤷ���⥸�塼�������ɤ��롣 ���δؿ��� modname �����Ǥ˥����ɤ���Ƥ��뤫�ɤ�������ꤹ�뤿��� �ޤ��ơ��֥� package.loaded ��õ���� �⤷���Ǥ˥����ɤ���Ƥ���С�require �� package.loaded[modname] �˳�Ǽ����Ƥ����ͤ��֤��� �����Ǥʤ���С��⥸�塼��� ������ ��õ����

��������õ������ˡ� require �Ϥޤ� package.preload[modname] ���䤤��碌�롣 �⤷�������ͤ�����С������� (�ؿ��Ǥ���٤��Ǥ���) ���������Ǥ��롣 �����Ǥʤ���С�require �� package.path �˳�Ǽ����Ƥ���ѥ���Ȥ� Lua�Υ�������õ���� ����⼺�Ԥ����顢package.cpath �˳�Ǽ����Ƥ���ѥ���Ȥ�C�Υ�������õ���� �����ޤ����Ԥ����顢�����륤��������� (��������) ����

C�Υ饤�֥�������ɤ����硢 require �Ϥޤ����ץꥱ�������򤽤Υ饤�֥��ȥ�󥯤��뤿��Υ����ʥߥå���󥯵�ǽ��Ȥ��� ���ˤ��Υ饤�֥���⤫��������Ȥ��ƻȤ������C�δؿ���õ���� ����C�δؿ��� "luaopen_" �˥⥸�塼��̾���դ���̾���Ǥ��뤬�� �ɥåȤϥ���������������ִ����롣 ����ˡ��⥸�塼��̾�˥ϥ��ե󤬴ޤޤ�Ƥ���С� ���κǽ�Υϥ��ե�ޤǤ���Ƭ���� (�ϥ��ե��ޤ��) ��������롣 �㤨�С��⥸�塼��̾�� a.v1-b.c �ξ�硢�ؿ�̾�� luaopen_b_c �Ȥʤ롣

require ��Lua�Υ饤�֥��ˤ�C�Υ饤�֥��ˤ�⥸�塼��򸫤Ĥ����ʤ���С� �����륤��������� ��Ƥ֡� ���Υ�������C�Υѥ��򸫤ơ����ꤷ���⥸�塼��Υ롼��̾���Ф���饤�֥���õ���� �㤨�� a.b.c ���׵ᤵ�줿��硢a �Ȥ���C�Υ饤�֥���õ���� �⤷���Ĥ���С����Υ��֥⥸�塼����Ф��륪���ץ�ؿ��򤽤��椫��õ���� �����Ǥ����ȡ�luaopen_a_b_c �Ȥʤ롣 ���ε�ǽ�ˤ�ꡢ�����Ĥ��C�Υ��֥⥸�塼���ҤȤĤΥ饤�֥���Ǽ��뤳�Ȥ��Ǥ��롣 ���ξ��Ǥ�ƥ��֥⥸�塼��ϡ����줾���ȼ��Υ����ץ�ؿ�����ġ�

�����������Ĥ���С� require ��ñ��ΰ��� modname ���Ϥ��ƥ�������Ƥ֡� �����������餫���ͤ��֤��ȡ� require �Ϥ���� package.loaded[modname] �˳�Ǽ���롣 ���������ͤ��֤�����package.loaded[modname] �˲����ͤ��Ǽ����Ƥ��ʤ���С� require �Ϥ��Υ���ȥ�� true ���Ǽ���롣 ������ˤ��衢require �Ϻǽ�Ū�� package.loaded[modname] ���ͤ��֤���

�⥸�塼��Υ����ɤޤ��ϼ¹Ԥǥ��顼�����ä��ꡢ���Υ⥸�塼��Υ����������Ĥ���ʤ���С� require �ϥ��顼��ȯ�����롣


package.cpath

C�Υ�������õ������� require ���Ȥ��ѥ���

Lua�ϴĶ��ѿ� LUA_CPATH (�˲ä��ơ�luaconf.h ���������Ƥ���⤦�ҤȤĤΥǥե���ȥѥ�) ��Ȥäơ� Lua�Υѥ� package.path ��Ʊ����ˡ�� C�Υѥ� package.cpath ���������롣


package.loaded

���Ǥ˥����ɤ��줿�⥸�塼���������뤿��� require ���Ȥ��ơ��֥롣 �⥸�塼�� modname ���׵ᤵ�졢 package.loaded[modname] �����Ǥʤ���С� require ��ñ�ˡ������˳�Ǽ����Ƥ����ͤ��֤���


package.loadlib (libname, funcname)

�ۥ��ȥץ�������C�Υ饤�֥�� libname ��ưŪ��󥯤��롣 ���Υ饤�֥�����Ǵؿ� funcname ��õ�������δؿ���C�δؿ��Ȥ����֤� (���äơ�funcname �ϸƤӽФ����� (lua_CFunction �򻲾�) �˽���ʤ���Фʤ�ʤ�)��

��������٥�ʴؿ��Ǥ��ꡢ�ѥå����������ƥ��⥸�塼�륷���ƥ�����˱��󤹤롣 require �Ȱۤʤꡢ �ѥ�õ����Ԥä����ĥ�Ҥ�ưŪ���ղä����ꤷ�ʤ��� libname ��C�Υ饤�֥��δ����ʥե�����̾�Ǥʤ���Фʤ餺�� ɬ�פʤ�ѥ����ĥ�Ҥ�ޤ�ʤ���Фʤ�ʤ��� funcname ��C�Υ饤�֥�꤬�������ݡ��Ȥ��Ƥ��봰����̾���Ǥʤ���Фʤ�ʤ� (�ȤäƤ���C����ѥ�����󥫤˰�¸����Ǥ�����)��

���δؿ���ANSI C�Υ��ݡ����ϰϳ��Ǥ��롣 ���äơ�����Ϥ����Ĥ��Υץ�åȥե����� (Windows, Linux, Mac OS X, Solaris, BSD, ����� dlfcn ɸ��򥵥ݡ��Ȥ���¾��Unix�����ƥ�) �Ǥ������ѤǤ��ʤ���


package.path

Lua�Υ�������õ������� require ���Ȥ��ѥ���

��ư����Lua�ϴĶ��ѿ� LUA_PATH ���͡� �ޤ��Ϥ��δĶ��ѿ����������Ƥ��ʤ���� luaconf.h ���������Ƥ���ǥե���ȥѥ��ǡ������ѿ����������롣 �Ķ��ѿ����ͤ� ";;" ������С������ǥե���ȥѥ����ִ����롣

�ѥ��ϥ��ߥ�����Ƕ��ڤ�줿��Ϣ�� �ƥ�ץ졼�� �Ǥ��롣 �ƥƥ�ץ졼�ȤˤĤ��ơ� require �� �ƥ�ץ졼����ε����� (interrogation mark) �� �ե�����̾ ���ִ����� ��̤Υե�����̾������ɤ��褦�Ȼ�ߤ롣 ���Υե�����̾�ϡ��⥸�塼��̾�ΥɥåȤ� �֥ǥ��쥯�ȥ���ڤ�ʸ���� (Unix�� "/" �Τ褦��) ���֤���������ΤǤ��롣 �㤨�С�Lua�Υѥ���

  "./?.lua;./?.lc;/usr/local/?/init.lua"
�Ǥ��ä���硢�⥸�塼�� foo ��Lua�Υ������θ����ϡ� �ե����� ./foo.lua��./foo.lc�� /usr/local/foo/init.lua �Υ����ɤ򤳤ν���ǻ�ߤ롣


package.preload

����Υ⥸�塼��Υ��������Ǽ����ơ��֥� (require �򻲾�)��


package.seeall (module)

__index �ե�����ɤ��������Х�Ķ��򻲾Ȥ���᥿�ơ��֥�� module �˥��åȤ��롣 ���äƤ��Υ⥸�塼��ϥ������Х�Ķ������ͤ�Ѿ����롣 �ؿ� module �ؤΥ��ץ����Ȥ��ƻȤ��롣

5.4 - ʸ�������

���Υ饤�֥��ϡ���������ʬʸ�������С��ѥ�����ޥå��󥰤Ȥ��ä���ʸ�������Τ���ΰ���Ū�ʵ�ǽ���󶡤��롣 Lua��ʸ����Υ���ǥå����դ��ϡ��ǽ��ʸ����1�ΰ��֤Ǥ��� (C�Τ褦��0�ǤϤʤ�)�� ʸ�������������������˥ޥ��ʥ��ͤǻ��ꤹ�뤳�Ȥ�Ǥ��롣 �Ĥޤꡢ�Ǹ��ʸ���� -1 �ΰ��֤Ǽ�����롣

ʸ����饤�֥��Ϥ��٤ơ��ơ��֥� string ��δؿ��Ȥ����󶡤���롣 �ޤ���__index �ե�����ɤ����Ȥ�ؤ�ʸ�����ѥ᥿�ơ��֥�򥻥åȤ��롣 ���äơ�ʸ����ؿ��ϥ��֥������Ȼظ���������ǻȤ����Ȥ��Ǥ��롣 �㤨�С�string.bytes(s, i) �� s:byte(i) �Ƚ񤯤��Ȥ�Ǥ��롣


string.byte (s [, i [, j]])

ʸ�� s[i], s[i+1], ..., s[j] �����������ɤο��ͤ��֤��� i �Υǥե���Ȥ�1�� j �Υǥե���Ȥ� i �Ǥ��롣

ʸ�������ɤο��ͤϡ��ץ�åȥե������Ķ���Ƥβ��������ʤ����Ȥ����ա�


string.char (i1, i2, ...)

0�İʾ�����������Ǥ��롣 ��ʸ����Ϳ����줿���������������������ɤ������Ĺ���������ο�����������ʸ������֤���

ʸ�������ɤο��ͤϡ��ץ�åȥե������Ķ���Ƥβ��������ʤ����Ȥ����ա�


string.dump (function)

���ꤵ�줿�ؿ��ΥХ��ʥ�ɽ�����ݻ�����ʸ������֤��� loadstring �ˤ���ʸ������Ϥ����Ȥǡ��ؿ��Υ��ԡ����뤳�Ȥ��Ǥ��롣 function �Ͼ���ͤ�����ʤ�Lua�ؿ��Ǥʤ���Фʤ�ʤ���


string.find (s, pattern [, init [, plain]])

ʸ���� s ��� pattern �κǽ�Υޥå���õ���� �⤷�ޥå������Ĥ���С�find �� s ��Ǥ��Υѥ����󤬥ޥå��������ϰ��֤Ƚ�λ���֤Υ���ǥå������֤��� �����Ǥʤ���� nil ���֤��� �����ܤξ�ά��ǽ�ʰ��� init �ϸ������ϰ��֤���ꤷ���ǥե�����ͤ�1�ǡ�����ͤ�Ȥ��롣 �����ܤξ�ά��ǽ�ʰ��� plain �� true �����ꤵ���ȡ� �ѥ�����ޥå��󥰵�ǽ�ϥ��դˤʤꡢ pattern ��Ρ���ˡ�Ρ�ʸ����̵���ʤäơ������Ρ���ʬʸ����򸡺���������ˤʤ롣 plain ��Ϳ������� init ��Ϳ���ʤ���Фʤ�ʤ����Ȥ����ա�

�⤷�ѥ�������˥���ץ��㤬���ꤵ��Ƥ���С� �ޥå��������˥���ץ��㤵�줿ʸ����2�ĤΥ���ǥå����θ���֤���롣


string.format (formatstring, e1, e2, ...)

�ǽ�ΰ��� (ʸ����Ǥʤ���Фʤ�ʤ�) �ǻ��ꤵ�줿���Ҥ˽������Ĥ�β��ѸĤΰ�����񼰲������֤��� ��ʸ�����ɸ��C�ؿ���printf�ե��ߥ꡼��Ʊ���롼��˽����� �������� *��l��L��n��p��h �ϥ��ݡ��Ȥ���Ƥʤ��ơ��ɲä� q ���������������ۤʤ롣 q ���ץ����ϡ�Lua���󥿥ץ꥿�ǰ������ɤ��᤻��Ŭ�ڤʷ�����ʸ����˽񼰲����롣 ����ʸ����ϥ��֥륯�����Ȥδ֤˽񤫤졢 ʸ������Υ��֥륯�����ȡ����ԡ������ޤ줿�������Хå�����å�������������������פ���롣 �㤨�С�
       string.format('%q', 'a string with "quotes" and \n new line')
�ϼ��Τ褦��ʸ������������롣
"a string with \"quotes\" and \
 new line"

c��d��E��e��f, g��G��i��o��u, X��x �Ϥ��٤ƿ��ͤΰ�������Ԥ��� q �� s ��ʸ�������Ԥ��롣

���δؿ��������ޤ줿������ޤ�ʸ���������դ��ʤ���


string.gmatch (s, pattern)

�ƤФ�뤿�Ӥ�ʸ���� s ���� pattern �ǥ���ץ��㤵�줿��ʬ�򼡡����֤��褦�ʡ����ƥ졼���ؿ����֤���

pattern �˥���ץ��㤬���ꤵ��Ƥ��ʤ���С����줾��θƤӽФ����Ȥˡ��ޥå�����ʸ�������Τ��֤���

�㤨�С��ʲ��Υ롼�פǤ�

  s = "hello world from Lua"
  for w in string.gmatch(s, "%a+") do
    print(w)
  end
ʸ���� s �Τ��٤Ƥ�ñ��ˤĤ��Ʒ����֤������줾����̡��ιԤ˽��Ϥ��롣 ������ϡ�Ϳ����줿ʸ���󤫤� key=value �Υڥ��򽸤�ƥơ��֥������롣
  t = {}
  s = "from=world, to=Lua"
  for k, v in string.gmatch(s, "(%w+)=(%w+)") do
    t[k] = v
  end


string.gsub (s, pattern, repl [, n])

�ѥ����� pattern �򤹤٤� repl �ˤ�äƻ��ꤵ�줿�ִ�ʸ������֤������� s �Υ��ԡ����֤��� repl ��ʸ���󡢥ơ��֥롢�ޤ��ϴؿ��Ǥ�褤�� gsub �������ܤ��ͤȤ��ơ��ִ����Ԥ�줿������֤���

repl ��ʸ����Ǥ���С������ͤ��ִ��˻Ȥ��롣 ʸ�� % �ϥ���������ʸ���Ȥ��Ƶ�ǽ���롣 repl ��˸���� %n �� (n ��1����9)�� n ���ܤ˥���ץ��㤵�줿��ʬʸ�����ɽ�� (�ʲ��򸫤�)�� �������� %0 �ϥޥå����Τ�ɽ���� �������� %% ��1�Ĥ� % ��ɽ����

repl ���ơ��֥�Ǥ���С� ���Υơ��֥�Ϻǽ�Υ���ץ���򥭡��Ȥ��ƥޥå��Τ��Ӥ��䤤��碌���롣 �ѥ�����˥���ץ��㤬�ʤ���С��ޥå����Τ������Ȥ��ƻȤ��롣

repl ���ؿ��Ǥ���С��ޥå�������뤿�Ӥˤ��δؿ����ƤФ�롣 �ؿ��ˤϥ���ץ��㤵�줿��ʬʸ���󤬽��֤ˤ��٤��Ϥ���롣 �ѥ�����˥���ץ��㤬���ꤵ��Ƥ��ʤ���С��ޥå��������Τ�ͣ��ΰ����Ȥ����Ϥ���롣 �ơ��֥��䤤��碌�ޤ��ϴؿ��ƤӽФ������֤��줿�ͤ�ʸ���󤫿��ͤǤ���С� ���줬�ִ�ʸ����Ȥ��ƻȤ��롣 �����Ǥʤ��� false �� nil �Ǥ���С��ִ��ϹԤ��ʤ� (�Ĥޤꡢʸ������θ��Υޥå����ݻ������)��

��ά��ǽ�ʺǸ�ΰ��� n ���ִ����Ԥ�������������¤��롣 �㤨�С�n ��1�ʤ�ǽ�˸���� pattern �������ִ�����롣

�����Ĥ���򼨤���

   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"


string.len (s)

ʸ����������ꡢ����Ĺ�����֤��� ��ʸ���� "" ��Ĺ����0�Ǥ��롣 ʸ������Υ����������Τǡ�"a\000b\000c" ��Ĺ����5�Ǥ��롣


string.lower (s)

ʸ����������ꡢ���������ʸ���򤹤٤ƾ�ʸ�����Ѥ���ʸ����Υ��ԡ����֤��� ����ʳ���ʸ�����Ѳ����ʤ��� ������ʸ���Ǥ��뤫�ϸ��ߤΥ�������˰�¸���롣


string.match (s, pattern [, init])

ʸ���� s ���� pattern �κǽ�� �ޥå� ��õ���� ���Ĥ��ä���硢match �ϥѥ�����Υ���ץ�����֤��� �����Ǥʤ���� nil ���֤��� pattern �˥���ץ��㤬�ʤ���С��ޥå����Τ��֤���롣 3�Ĥ�ξ�ά��ǽ�ʿ��ͤΰ��� init �ϸ����򳫻Ϥ�����֤���ꤹ�롣 �ǥե�����ͤ�1�ǡ�����ͤ���ꤷ�Ƥ�褤��


string.rep (s, n)

ʸ���� s �Υ��ԡ��� n ��Ϣ�뤷��ʸ������֤���


string.reverse (s)

ʸ���� s ��ȿž����ʸ������֤���


string.sub (s, i [, j])

ʸ���� s �Ρ����� i ������� j �ޤǤ���ʬʸ������֤��� i �ˤ� j �ˤ⡢����ͤ�Ȥ��롣 j ����ά���줿�Ȥ��� -1 �Ȥߤʤ���� (�Ĥޤ�ʸ�����Ĺ����Ʊ��)�� �äˡ�string.sub(s,1,j) �� s ����Ƭ���� j ʸ������Ф��� string.sub(s, -i) �� s �κǸ�� i ʸ������Ф���


string.upper (s)

ʸ����������ꡢ������ξ�ʸ���򤹤٤���ʸ�����Ѥ���ʸ����Υ��ԡ����֤��� ����ʳ���ʸ�����Ѳ����ʤ��� ������ʸ���Ǥ��뤫�ϸ��ߤΥ�������˰�¸���롣

Patterns

ʸ�����饹 ��ʸ���ν����ɽ���� �ʲ����Ȥ߹�碌��ʸ�����饹�λ���˻Ȥ����Ȥ��Ǥ��롣

�ҤȤĤ�ʸ����ɽ������륯�饹 (%a��%c�ʤ�) �Ϥ��٤ơ��б�������ʸ�����佸���ɽ���� �㤨�� %S �϶���ʳ��Τ��٤Ƥ�ʸ����ɽ����

ʸ�������򡢤���¾��ʸ���Υ��롼�פ�����ˤĤ��Ƥϡ����ߤΥ�������˰�¸���롣 �äˡ����饹 [a-z] �� %l �������ǤϤʤ����⤷��ʤ���

�ѥ���������� �ϰʲ��Τ����줫�Ǥ��롣

pattern �ϥѥ��������Ǥ���Ǥ��롣 �ѥ�����κǽ�˸���� `^�� ���о�ʸ�������Ƭ�˥ޥå�����ꤹ�롣 �ѥ�����κǸ�˸���� `$�� ���о�ʸ����κǸ�˥ޥå�����ꤹ�롣 ¾�ΰ��֤Ǥϡ�`^�� �� `$�� �����̤ʰ�̣������������켫�Ȥ�ɽ����

�ѥ�����ϥ��å��ǰϤޤ줿���֥ѥ��������Ĥ��Ȥ��Ǥ��������� ����ץ��� �ȸƤФ�롣 �ޥå������������Ȥ����о�ʸ�������ǥ���ץ���˥ޥå�������ʬ����¸ (����ץ���) ���졢��ǻȤ����Ȥ��Ǥ��롣 ����ץ���Ϥ��κ����å��ˤ�ä��ֹ��դ�����롣 �㤨�С��ѥ����� "(a*(.)%w(%s*))" �Ǥϡ� "a*(.)%w(%s*)" �˥ޥå�������ʬ���ǽ�Υ���ץ���Ȥ�����¸���� (������1�֤ˤʤ�)�� "." �˥ޥå�����ʸ����2�֤˥���ץ��㤵�졢 "%s*" �˥ޥå�������ʬ��3�֤ˤʤ롣

�ü�ʥ������Ȥ��ơ�������ץ��� () ��ʸ����θ��߰��� (����) �򥭥�ץ��㤹�롣 �㤨�С�ʸ���� "flaaap" �˥ѥ����� "()aa()" ��Ŭ�Ѥ���ȡ� 2�ĤΥ���ץ���3��5�������롣

�ѥ�����ˤ�����˥�����ޤळ�Ȥ��Ǥ��ʤ�������� %z ��Ȥ���

5.5 - �ơ��֥����

���Υ饤�֥��ϥơ��֥����Τ���ΰ���Ū�ʵ�ǽ���󶡤��롣 �ơ��֥� table ��ˤ��٤Ƥδؿ����󶡤���롣 �����δؿ��ǥơ��֥�Ρ�Ĺ���פˤĤ��Ƹ��ڤ���Ȥ��ϡ� �����Ĺ���黻�Ҥη�̤��̣���Ƥ��롣


table.concat (table [, sep [, i [, j]]])

table[i]..sep..table[i+1] ... sep..table[j] ���֤��� sep �Υǥե�����ͤ϶�ʸ����ǡ� i �Υǥե�����ͤ�1�� j �Υǥե�����ͤϥơ��֥��Ĺ���Ǥ��롣 i �� j �����礭�����϶�ʸ������֤���


table.insert (table, [pos,] value)

table �ΰ��� pos ������ value ���������롣 �������ڡ�����ɬ�פʤ顢¾�����Ǥ��ˤ��餹�� pos �Υǥե�����ͤ� n+1 �Ǥ��롣 n �ϥơ��֥��Ĺ���Ǥ��� (2.5.5 �򻲾�)�� table.insert(t,x) �θƤӽФ��ϡ��ơ��֥� t �κǸ�� x ���������롣


table.maxn (table)

���ꤷ���ơ��֥�κ�������ο��ͥ���ǥå������֤��� �ơ��֥뤬���ο��ͥ���ǥå���������ʤ���Х������֤��� (��̤����뤿��ˡ����δؿ��ϥơ��֥����Τ������˽�󤹤롣)


table.remove (table [, pos])

table ������� pos �����Ǥ�������� ɬ�פʤ�¾�����Ǥ򲼤ˤ��餷�ƶ�������롣 �������줿���Ǥ��ͤ��֤���롣 pos �Υǥե�����ͤ� n �Ǥ��롣 n �ϥơ��֥��Ĺ���Ǥ��롣 table.remove(t) �θƤӽФ��ϡ��ơ��֥� t �κǸ�����Ǥ��������


table.sort (table [, comp])

table[1] ���� table[n] �ޤǤΥơ��֥����Ǥ򡢻��ꤵ�줿����� ���ξ�� �����Ȥ��롣 n �ϥơ��֥��Ĺ���Ǥ��롣 comp ��Ϳ�����硢����ϴؿ��Ǥʤ��ƤϤʤ餺���ơ��֥�����Ǥ�2�ļ�����ꡢ�ǽ�����Ǥ������ܤ��⾮�����Ȥ��˿����֤��ʤ���Фʤ�ʤ� (�����ȸ塢not comp(a[i+1],a[i]) �����ˤʤ�)�� comp ��Ϳ�����ʤ���С�ɸ���Lua�α黻�� < ������˻Ȥ��롣

�����ȤΥ��르�ꥺ��ϰ����Ǥʤ��� �Ĥޤꡢ���ꤵ�줿����ˤ������������ȹͤ��������Ǥϡ������Ȥˤ�äƤ������а��֤��Ѥ�뤫�⤷��ʤ���

5.6 - ���شؿ�

���Υ饤�֥���ɸ��C���إ饤�֥��ؤΥ��󥿥ե������Ǥ��롣 math �ơ��֥����ˤ��٤Ƥδؿ����󶡤���롣 ���Υ饤�֥��ϰʲ��δؿ����󶡤���:

       math.abs     math.acos    math.asin    math.atan    math.atan2
       math.ceil    math.cos     math.cosh    math.deg     math.exp
       math.floor   math.fmod    math.frexp   math.ldexp   math.log
       math.log10   math.max     math.min     math.modf    math.pow
       math.rad     math.random  math.randomseed           math.sin
       math.sinh    math.sqrt    math.tan     math.tanh
�ä��ơ��ѿ� math.pi �ȡ��� HUGE_VAL ������ѿ� math.huge ���󶡤���롣 �����ΤۤȤ�ɤϡ�C�饤�֥����б�����ؿ��ؤ�ñ�ʤ륤�󥿥ե������Ǥ��롣 ���٤Ƥλ��Ѵؿ��ϥ饸�����Ȥ��� �ؿ� math.deg �� math.rad �ϥ饸������٤��Ѵ����롣

�ؿ� math.max �ϰ�������κ����ͤ��֤��� Ʊ�ͤ� math.min �ϺǾ��ͤ���롣 ����1�ġ�2�ġ����뤤�Ϥ�äȤ�������ΰ������Ϥ����Ȥ��Ǥ��롣

�ؿ� math.modf ��C�δؿ� modf ���б����롣 �����2�Ĥ��͡��������������Ⱦ��������֤��� �ؿ� math.frexp ��2�Ĥ��͡� �����������������������Ȼؿ������֤���

�ؿ� math.random �� math.randomseed �� ANSI C ���󶡤����ñ��ʥ����������ؿ� rand �� srand �ؤΥ��󥿥ե������Ǥ��� (����Ū���������ݾڤ���ʤ�)�� ����̵���ǸƤФ��ȡ�math.random �� [0,1) ���ϰϤμ¿��ε���������֤��� ���� n ���Ϥ��ȡ�math.random �� [1,n] ���ϰϤ������ε���������֤��� 2�Ĥΰ��� l �� u ���Ϥ��ƸƤ���Ȥ��ϡ� math.random �� [l,u] ���ϰϤ������ε���������֤��� math.randomseed �ؿ��ϵ������ȯ����Ρ֥������͡פ����ꤹ�롣 Ʊ���������ͤ����Ʊ��������������롣

5.7 - �����ϵ�ǽ

I/O�饤�֥���2�Ĥΰۤʤä���������Υե����������󶡤��롣 �ҤȤĤ�ϰ��ۤΥե�����ǥ�������ץ���Ȥ���Τǡ� �����ϥǥե�������ϥե�����ȥǥե���Ƚ��ϥե�������Ф��ƺ��Ѥ��� ���٤Ƥ����������ϥǥե���ȥե�������̤��ƹԤ��롣 �դ��Ĥ�Υ�������Ǥ�����Ū�ʥե�����ǥ�������ץ����Ѥ��롣

���ۤΥե�����ǥ�������ץ���Ȥ����ϡ����٤Ƥ����ϥơ��֥� io ���󶡤���롣 ����Ū�ʥե�����ǥ�������ץ���Ȥ����ϡ� ���٤Ƥ����� io.open ���֤��ե�����ǥ�������ץ��Υ᥽�åɤȤ����󶡤���롣

�ơ��֥� io �ϡ� C�ǻȤ����̣��Ʊ����3�Ĥ�����Ѥߥե�����ǥ�������ץ� io.stdin��io.stdout��io.stderr ���󶡤��롣

�㳰�ʤ������٤Ƥ�I/O�ؿ��ϼ��Ի��� nil (����������ܤ�����ͤȤ��ƥ��顼��å�����) ���֤��� �������� nil �ʳ��β��餫���ͤ��֤���


io.close ([file])

file:close() �������Ǥ��롣 file ����ά�����ȡ��ǥե���Ƚ��ϥե�������Ĥ��롣


io.flush ()

�ǥե���Ƚ��ϥե�������Ф��� file:flush �������Ǥ��롣


io.input ([file])

�ե�����̾��Ϳ���ƸƤ֤ȡ�����̾���Υե������ (�ƥ����ȥ⡼�ɤ�) ������ ���Υϥ�ɥ��ǥե�������ϥե���������ꤹ�롣 �ե�����ϥ�ɥ��Ϳ���ƸƤ֤ȡ�ñ��ˤ��Υե�����ϥ�ɥ뤬�ǥե�������ϥե���������ꤵ��롣 ����̵���ǸƤ֤ȡ����ߤΥǥե�������ϥե�������֤���

���顼����������硢���δؿ��ϥ��顼�����ɤ��֤��Ѥ��˥��顼��ȯ���롣


io.lines ([filename])

���ꤵ�줿�ե�����̾���ɤ߹��ߥ⡼�ɤdz����� �ƤФ�뤿�Ӥ˥ե����뤫��1�Ԥ����֤����ƥ졼���ؿ����֤��� �Ĥޤꡢ

       for line in io.lines(filename) do ... end
�ϥե�����Τ��٤ƤιԤˤĤ��Ʒ����֤��� ���ƥ졼���ؿ��ϡ��ե�����ν����򸡽Ф���� nil ���֤� (�롼�פ򽪤��뤿��)����ưŪ�˥ե�������Ĥ��롣

io.lines() (�ե�����̾���Ϥ��ʤ�) �� io.input():lines() �������Ǥ��롣 ���ʤ�����ǥե�������ϥե�����γƹԤˤĤ��Ʒ����֤��� ���ξ��ϡ��롼�פ�����äƤ�ե�������Ĥ��ʤ���


io.open (filename [, mode])

���δؿ��� mode �ǻ��ꤵ�줿�⡼�ɤǥե�����򳫤��� �������ե�����ϥ�ɥ���֤��������顼�ξ��� nil �ȥ��顼��å��������֤���

mode ʸ����ϰʲ��Τ����줫�Ǥ��롣

mode ʸ����ϺǸ�� `b�� ���դ��뤳�Ȥ��Ǥ��� �����ƥ�ˤ�äƤϥХ��ʥ�⡼�ɤǥե�����򳫤������ɬ�פǤ��롣 ����ʸ�����ɸ��C�δؿ� fopen �ǻȤ���Τ�Ʊ���Ǥ��롣


io.output ([file])

io.input ��Ʊ���Ǥ��뤬���ǥե���Ƚ��ϥե�������Ф������Ǥ��롣


io.popen ([prog [, mode]])

ʬΥ���줿�ץ���������ǥץ������ prog �򳫻Ϥ��� ���Υץ�����फ��Υǡ������ɤ߹��� (�ǥե���ȤΡ�mode �� "r" �ξ��) ���ᤫ�����Υץ������˥ǡ�����񤭹��� (mode �� "w" �ξ��) ����Υե�����ϥ�ɥ���֤���

���δؿ��ϥ����ƥ��¸�Ǥ��ꡢ���٤ƤΥץ�åȥե���������Ѳ�ǽ�ʤ櫓�ǤϤʤ���


io.read (format1, ...)

io.input():read �������Ǥ��롣


io.tmpfile ()

�ƥ�ݥ��ե�����Υϥ�ɥ���֤��� ���Υե�����Ϲ����⡼�ɤǥ����ץ󤵤졢�ץ������ν�λ���˼�ưŪ�˺������롣


io.type (obj)

obj ��ͭ���ʥե�����ϥ�ɥ뤫�ɤ��������å����롣 obj �������ץ󤵤�Ƥ���ե�����ϥ�ɥ�ʤ顢ʸ���� "file" ���֤��� obj �������������줿�ե�����ϥ�ɥ�ʤ顢ʸ���� "closed file" ���֤��� obj ���ե�����ϥ�ɥ�Ǥʤ���� nil ���֤���


io.write (value1, ...)

io.output():write �������Ǥ��롣


file:close ()

file ���Ĥ��롣 �ե�����ϥ�ɥ뤬���١������쥯�Ȥ��줿�Ȥ��Ϥ��Υե�����ϼ�ưŪ���Ĥ����뤬�� ���줬���ĵ����뤫��ͽ¬��ǽ�Ǥ��뤳�Ȥ����դ��衣


file:flush ()

file �˽񤭹��ޤ줿�ǡ�������¸���롣


file:lines ()

�ƤФ�뤿�Ӥ˥ե����뤫�鿷�����Ԥ��֤����ƥ졼���ؿ����֤��� �Ĥޤꡢ

       for line in file:lines() do ... end
�ϥե�����Τ��٤ƤιԤ��Ф��Ʒ����֤� (io.lines �Ȱۤʤꡢ���δؿ��ϥ롼�פν����ǥե�������Ĥ��ʤ�)��


file:read (format1, ...)

�����ɤफ����ꤹ��񼰤˽��äơ��ե����� file �����ɤ߹��ࡣ �ƽ񼰤ˤĤ��ơ��ɤ߹����ʸ����ʸ���� (�ޤ��Ͽ���) �Ȥ����֤��� ���ꤵ�줿�񼰤ǥǡ������ɤ�ʤ���� nil ���֤��� �񼰤���ꤻ���˸ƤФ줿���ϡ����ι����Τ��ɤ�ǥե���Ȥν񼰤��Ȥ��� (�ʲ��򻲾�)��

���Ѳ�ǽ�ʥե����ޥåȤϼ����̤ꡣ


file:seek ([whence] [, offset])

�ե��������Ƭ����פä��ե�������֤�����/�������롣 ���֤�ʸ���� whence �ǻ��ꤵ�줿�����֤� offset ��ä����ͤǼ����� whence �ϰʲ��Τ����줫�Ǥ��롣

��������ȡ��ؿ� seek �ϥե�������Ƭ����ΥХ��ȿ��Ǻǽ�Ū�ʥե�������֤��֤��� ���δؿ������Ԥ���� nil �ȥ��顼ʸ������֤���

whence �Υǥե�����ͤ� "cur" �ǡ� offset ��0�Ǥ��롣 �Ĥޤꡢfile:seek() �θƤӽФ��ϡ������Ѳ��������ˡ����ߤΰ��֤��֤��� file:seek("set") �ϥե��������Ƭ�˰��֤��ѹ����� (������0���֤�)�� file:seek("end") �ϥե�����ν����˰��֤��ѹ������ե������Ĺ�����֤���


file:setvbuf (mode [, size])

���ϥե�����ΥХåե���󥰥⡼�ɤ����ꤹ�롣 �����ǽ�ʥ⡼�ɤ�3�Ĥ��롣

����2�Ĥξ��Ǥϡ� sizes �ǥХåե��Υ�������Х���ñ�̤ǻ���Ǥ��롣 �ǥե���ȤΥ�������Ŭ���Ǥ��롣


file:write (value1, ...)

�����Τ��줾����ͤ� file �˽񤭹��ࡣ ������ʸ���󤫿����Ǥʤ���Фʤ�ʤ��� ����ʳ����ͤ�񤭹���ˤϡ� write ������ tostring �� string.format ��Ȥ���

5.8 - OS��ǽ

���Υ饤�֥��ϥơ��֥� os ���̤����󶡤���롣


os.clock ()

�ץ�����ब�Ȥä�CPU���֤γ����ͤ��ä��֤���


os.date ([format [, time]])

Ϳ����줿ʸ���� format �˽��äƽ񼰲��������դȻ����ޤ�ʸ���󡢤ޤ��ϥơ��֥���֤���

time ������¸�ߤ���С����줬�񼰲���������Ȥʤ� (�����ͤ������� os.time �ؿ��򻲾�)�� �����Ǥʤ���С�date �ϸ��߻����񼰲����롣

format �� `!�� �ǻϤޤäƤ����顢 ���դ������� (Universal Time) �ǽ񼰲�����롣 ���Υ��ץ����ʸ���θ塢 format �� *t �Ǥ���С� date �ϰʲ��Υե�����ɤ���ĥơ��֥���֤���

format �� *t �Ǥʤ���С� date �����դ�ʸ����Ȥ����֤��� C�δؿ� strftime ��Ʊ���롼��˽��äƽ񼰲�����롣

�����ʤ��ǸƤФ줿��硢 date �ϥۥ��ȥ����ƥ�ȸ��ߤΥ�������˰�¸�������Ū�����դȻ����ɽ�����֤��� (�Ĥޤꡢos.date() �� os.date("%c") �������Ǥ���)��


os.difftime (t2, t1)

���� t1 ������� t2 �ޤǤ��ÿ����֤��� POSIX �� Windows������¾�Τ����Ĥ��Υ����ƥ�Ǥϡ� �����ͤ� t2-t1 ����������


os.execute ([command])

���δؿ���C�δؿ� system �������Ǥ��롣 command ��OS�Υ�����ˤ�äƼ¹Ԥ���륳�ޥ�ɤ��Ϥ��� �����ƥ�˰�¸���륹�ơ����������ɤ��֤��� command ���ά����ȡ������뤬���Ѳ�ǽ�ʤ饼���ʳ����֤��������Ǥʤ���Х������֤���


os.exit ([code])

��ά��ǽ�� code ��C�δؿ� exit ��Ƥ�ǥۥ��ȥץ�������λ�����롣 code �Υǥե�����ͤ�������ɽ�������ɤǤ��롣


os.getenv (varname)

�ץ������δĶ��ѿ� varname ���ͤ��֤��� �ѿ���̤����ʤ� nil ���֤���


os.remove (filename)

���ꤵ�줿̾���Υե�����ޤ��ϥǥ��쥯�ȥ��ä��� �ä��ǥ��쥯�ȥ�϶��Ǥʤ���Фʤ�ʤ��� ���δؿ������Ԥ������� nil �ȥ��顼��å��������֤���


os.rename (oldname, newname)

oldname �Ȥ���̾���Υե�����ޤ��ϥǥ��쥯�ȥ�� newname �˥�͡��ह�롣 ���δؿ������Ԥ������� nil �ȥ��顼��å��������֤���


os.setlocale (locale [, category])

�ץ������θ��ߤΥ�����������ꤹ�롣 locale �ϥ��������ɽ��ʸ����Ǥ��롣 category ���ѹ����������ƥ����ɽ����ά��ǽ��ʸ����ǡ��ʲ��Τ����줫�Ǥ��롣 "all", "collate", "ctype", "monetary", "numeric", or "time"�� �ǥե���ȤΥ��ƥ���� "all" �Ǥ��롣 ���δؿ��Ͽ��������������̾�����֤��� ���뤤���׵᤬�����դ����ʤ���� nil ���֤���


os.time ([table])

����̵���ǸƤФ줿�Ȥ��ϸ��ߤλ�����֤��� ������������ϡ�Ϳ����줿�ơ��֥�ǻ��ꤵ�줿���դȻ����ɽ��������֤��� ���Υơ��֥�ϥե������ year, month, and day ������ʤ���Фʤ餺�� ��ά��ǽ�����ե������ hour, min, sec, and isdst �����äƤ��ɤ� (�����Υե�����ɤ������� os.date �ؿ��򻲾�).

����ͤϿ��ͤǤ��ꡢ���ΰ�̣�ϥ����ƥ�˰�¸���롣 POSIX �� Windows������Ӥ����Ĥ��Υ����ƥ�Ǥϡ� ����γ��ϻ��� (�֥��ݥå���)����ηв���֤��ä�ɽ���Ƥ��롣 ����ʳ��Υ����ƥ�Ǥϡ����ΰ�̣�������Ǥ��ꡢ time ������ͤ� date �� difftime �ΰ����Ȥ��ƤΤ߻Ȥ����Ȥ��Ǥ��롣


os.tmpname ()

�ƥ�ݥ��ե�����Ȥ��ƻȤ���ե�����̾���֤��� ���Υե�����ϻȤ���������Ū�˥����ץ󤹤�ɬ�פ����ꡢ �פ�ʤ��ʤä�������Ū�˺蘆�ʤ���Фʤ�ʤ���

5.9 - �ǥХå��饤�֥��

���Υ饤�֥���Lua�ץ������ؤΥǥХå����󥿥ե������ε�ǽ���󶡤��롣 ���Υ饤�֥���Ȥ��Ȥ������դ��٤��Ǥ��롣 �������󶡤����ؿ��ϥǥХå��䤽��˻����ץ��ե�����󥰤Τ褦�ʥ������ˤΤ߻Ȥ��٤��Ǥ��롣 ���̤Υץ�����ߥ󥰥ġ���Ȥ��Ƥ�����Ȥ�Ͷ�Ǥ��񹳤���褦�ˡ� �����������٤��� ����˸����С������Ĥ��δؿ���Lua�����ɤˤĤ��ƤΤ����Ĥ��β��� (�ؿ��Υ��������ѿ���¾�δؿ����饢�������Ǥ��ʤ��Ȥ����桼�����ǡ����Υ᥿�ơ��֥��Lua�����ѹ��Ǥ��ʤ��Ȥ�) �򿯳����������ʥ����ɤ���������붲�줬���롣

���Υ饤�֥��Τ��٤Ƥδؿ��� debug �ơ��֥�����󶡤���롣


debug.debug ()

�桼�����Ȥ����å⡼�ɤ����ꡢ�桼���������Ϥ���ʸ�����¹Ԥ��롣 ñ��ʥ��ޥ�ɤ�¾�ΥǥХå���ǽ��Ȥäơ� �桼�����ϥ������Х��ѿ�����������ѿ���Ĵ�٤����ͤ��ѹ������꼰��ɾ�������ꤽ��¾���Ǥ��롣 �桼������ cont �����ιԤ����Ϥ�������å⡼�ɤ򽪤��Ƽ¹Ԥ��³���롣

debug.debug �Ǽ¹Ԥ���륳�ޥ�ɤϡ� �ɤδؿ��Υ쥭�����륹�����פˤ����äƤ��ʤ��Τǡ� ���������ѿ��ؤ�ľ�ܥ��������Ǥ��ʤ����Ȥ����ա�


debug.getfenv (o)

���֥������� o �δĶ����֤���


debug.gethook ()

���ߤΥեå��ؿ����եå��ޥ������եå�������� (debug.sethook �ؿ������ꤵ�줿���) ���֤���


debug.getinfo (function [, what])

�ؿ��˴ؤ�������ơ��֥��������֤��� �ؿ���ľ�ܻ��ꤹ�뤫���ͤ���ꤹ�뤳�Ȥ��Ǥ��롣 ���ͤϡ��ؿ������äƤ��륳���륹���å��Υ�٥���̣���� ��٥�0�ϸ��ߤδؿ� (getinfo ����)�� ��٥�1�� getinfo ��ƤӽФ����ؿ��ǡ��ʲ�Ʊ�͡� function �������ƥ��֤ʴؿ��ο������礭�����ͤǤ���� getinfo �� nil ���֤���

what �ϤɤΥե�����ɤ����뤫�򵭽Ҥ���ʸ����ǡ� ����ͤΥơ��֥�ˤ� lua_getinfo �����֤����ե�����ɤ����٤ƴޤޤ�Ƥ��롣 what �Υǥե�����ͤǤ�ͭ���ʤ��٤Ƥξ����������롣 �⤷¸�ߤ���С�`f�� ���ץ����� func �Ȥ���̾���Υե�����ɤˤ��δؿ����Ȥ�����롣

�㤨�С��� debug.getinfo(1,"n").name �ϸ��ߤδؿ���̾�����֤� (�⤷Ŭ����̾���������)�� debug.getinfo(print) �� print �ؿ��˴ؤ��뤹�٤Ƥ����Ѳ�ǽ�ʾ������ĥơ��֥���֤���


debug.getlocal (level, local)

�����å���٥� level �δؿ��Ρ�����ǥå��� local �Υ��������ѿ��Ρ�̾�����ͤ��֤��� �ǽ�ΰ��������������ѿ�������ǥå���1�ǡ��ʲ�Ʊ�ͤ˺Ǹ��ͭ���ʥ��������ѿ��ޤ�³���� �⤷���ꤵ�줿����ǥå����Υ��������ѿ����ʤ���� nil ���֤��� level ���ϰϳ��Ǥ���Х��顼��ȯ���� (debug.getinfo ��Ȥäƥ�٥뤬ͭ�����ɤ��������å��Ǥ���)��

`(�� (�������) �ǻϤޤ��ѿ�̾������Ū���ѿ� (�롼�������ѿ�������ѿ���C�δؿ��Υ�������ʤ�) ��ɽ���Ƥ��롣


debug.getmetatable (object)

���ꤷ�� object �Υ᥿�ơ��֥���֤��� �᥿�ơ��֥����äƤ��ʤ���� nil ���֤���


debug.getregistry ()

�쥸���ȥ�ơ��֥� (3.5 �򻲾�) ���֤���


debug.getupvalue (func, up)

�ؿ� func �Ρ�����ǥå��� up �ξ���ͤΡ�̾�����ͤ��֤��� ���ꤵ�줿����ǥå����ξ���ͤ�¸�ߤ��ʤ���� nil ���֤���


debug.setfenv (object, table)

���ꤷ�� object �δĶ�����ꤷ�� table �ˤ��롣


debug.sethook (hook, mask [, count])

���ꤵ�줿�ؿ���եå������ꤹ�롣 ʸ���� mask �ȿ��� count �ϡ����ĥեå����ƤФ�뤫�򵭽Ҥ��롣 ʸ����mask�ϰʲ���ʸ������ʤ롣

count �������Ǥʤ���С��եå��� count ̿�᤬�¹Ԥ���뤿�Ӥˡ�����ľ��˸ƤФ�롣

�����ʤ��ǸƤ֤ȥեå���̵���ˤʤ롣

�եå����ƤФ줿�Ȥ����ǽ�ΰ����ϥեå���ư�������٥�Ȥ򼨤��ʲ��Τ����줫��ʸ����Ǥ��롣 "call", "return" "tail return", "line", "count"�� line���٥�Ȥξ�硢�եå��������ܤΰ����˿��������ֹ椬�����롣 "tail return" ������ơ� �եå��������ǥ�٥�2�� getinfo ��Ƥ٤С��¹���δؿ��˴ؤ��������ä������� (��٥�0�� getinfo �ؿ����Ȥǡ���٥�1�ϥեå��ؿ��Ǥ���)�� "tail return" ��Lua�������򥷥ߥ�졼�Ȥ��Ƥ�������Ǥ��ꡢ getinfo ���������ʤ��ǡ������֤���������


debug.setlocal (level, local, value)

�����å���٥� level �δؿ��Ρ�����ǥå��� local �Υ��������ѿ��ˡ��� value ���Ǽ���롣 ���ꤵ�줿����ǥå����Υ��������ѿ���¸�ߤ��ʤ���� nil ���֤��� level ���ϰϳ��Ǥ���Х��顼��ȯ���� (getinfo ��Ȥäƥ�٥뤬ͭ�����ɤ��������å��Ǥ���)�� �����Ǥʤ���С����������ѿ���̾�����֤���


debug.setmetatable (object, table)

���ꤷ�� object �Υ᥿�ơ��֥����ꤷ�� table (nil �Ǥ��ɤ�) �ˤ��롣


debug.setupvalue (func, up, value)

�ؿ� func �Ρ�����ǥå��� up �ξ���ͤˡ��� value ���Ǽ���롣 ���ꤵ�줿����ǥå����ξ���ͤ�¸�ߤ��ʤ���� nil ���֤��� �����Ǥʤ���С�����ͤ�̾�����֤���


debug.traceback ([message])

�����륹���å��Υȥ졼���Хå�����Ϥ���ʸ������֤��� ��ά��ǽ�� message ʸ����ϡ��ȥ졼���Хå��κǽ���դ��ä����롣 ���δؿ���ŵ��Ū�ˤϡ�����ɤ����顼��å��������������뤿��� xpcall �Ȱ��˻Ȥ��롣

6 - ������ɥ������Lua

Lua��C�Υۥ��ȥץ��������Ȥ߹��ޤ���ĥ����Ȥ��ƥǥ����󤵤줿�ˤ�ؤ�餺�� ������ɥ�����θ���Ȥ��Ƥ�褯�Ȥ��롣 ������ɥ�����θ���Ȥ��Ƥ�Lua���󥿥ץ꥿�ϡ�ñ��� lua �ȸƤФ졢 ɸ��Υǥ����ȥ�ӥ塼�����ȶ����󶡤���Ƥ��롣 ������ɥ�����Υ��󥿥ץ꥿�ϡ� �ǥХå��饤�֥���ޤह�٤Ƥ�ɸ��饤�֥�����äƤ��롣 �Ȥ����ϰʲ����̤ꡣ

      lua [options] [script [args]]
���ץ����ϰʲ����̤ꡣ �����Υ��ץ���󤬽������줿���ȡ�lua �ϻ��ꤵ�줿 script �� args ��ʸ����Ȥ����Ϥ��Ƽ¹Ԥ��롣 �����ʤ��ǸƤФ줿��硢 stdin (ɸ������) ��ü���Ǥ���� lua -v -i�� �����Ǥʤ���� lua - �Ȥ��ƿ����񤦡�

�ɤΰ�����Ŭ�Ѥ�������ˡ� ���󥿥ץ꥿�ϴĶ��ѿ� LUA_INIT ��Ĵ�٤롣 ���ν񼰤� @filename �Ǥ���С����Υե������¹Ԥ��롣 �����Ǥʤ���С�����ʸ���󼫿Ȥ�¹Ԥ��롣

-i �ʳ��Τ��٤ƤΥ��ץ����Ͻ��֤˽�������롣 �㤨�С��ʲ��Τ褦�ʥ��ޥ�ɤ�

       $ lua -e'a=1' -e 'print(a)' script.lua
�ޤ� a ��1�������������줫�� a ���� (�Ĥޤ� `1��) ��ɽ�������Ǹ�˥ե����� script.lua ��¹Ԥ��� (�����ǡ�$ �ϥ�����ץ���ץȤǤ��롣���ߤΥ�����ץ���ץȤϰ㤦���⤷��ʤ�)��

������ץȤ�¹Ԥ������ˡ�lua �ϥ��ޥ�ɥ饤������� arg �Ȥ���̾���Υ������Х�ʥơ��֥�˳�Ǽ���롣 ������ץ�̾������ǥå���0�˳�Ǽ���졢 �ǽ�Σ褭������������ץ�̾�θ�Υ���ǥå���1�˳�Ǽ���졢�ʲ�Ʊ�ͤǤ��롣 ������ץ�̾�����Τ��٤Ƥΰ��� (�Ĥޤꡢ���󥿥ץ꥿��̾���䥪�ץ����) ����Υ���ǥå����˳�����Ƥ��롣 �Ĥޤꡢ���Τ褦�ʾ��

       $ lua -la b.lua t1 t2
���󥿥ץ꥿�Ϥޤ��ե����� a.lua ��¹Ԥ��� ���˰ʲ��Τ褦�ʥơ��֥���롣
       arg = { [-2] = "lua", [-1] = "-la",
               [0] = "b.lua",
               [1] = "t1", [2] = "t2" }
�����ƺǸ�˥ե����� b.lua ��¹Ԥ��롣 ������ץȤϰ����Ȥ��� arg[1], arg[2], ... ���Ϥ���ƸƤФ�롣 ���Ѱ����� `...�� ��Ȥäư����˥����������뤳�Ȥ�Ǥ��롣

���å⡼�ɤǤϡ��Դ�����ʸ��񤤤��Ȥ��ϡ����줬������ʸ�ˤʤ�ޤ��Ԥġ�

�������Х��ѿ� _PROMPT ��ʸ�������äƤ���С� �����ͤ��ץ���ץȤ˻Ȥ��롣 Ʊ�ͤˡ��������Х��ѿ� _PROMPT2 ��ʸ�������äƤ���С� �����ͤ�����ץ���ץȤ˻Ȥ��� (�Դ�����ʸ�Ǥ���ֻȤ���)�� �Ĥޤꡢ�ץ���ץȤϥ��ޥ�ɥ饤�󤫤�ľ���ѹ��Ǥ��롣

       $ lua -e"_PROMPT='myprompt> '" -i
(��¦�Υ��������Фϥ�����Τ���Ρ���¦��Lua�Τ���Τ�Ρ�) �ޤ���_PROMPT ���������뤳�Ȥǡ�Lua�Υץ�����फ����ѹ��Ǥ��롣 ���å⡼�ɤ�����ˤ� -i ���פ뤳�Ȥ����ա� �����Ǥʤ���С��ץ������� _PROMPT ����������ľ��˲�����Ϥ��������Ǥ�������

Unix�����ƥ�ǥ�����ץȥ��󥿥ץ꥿�Ȥ���Lua��Ȥ���褦�ˤ��뤿��ˡ� ������ɥ����󥤥󥿥ץ꥿�ϥ���󥯤� # �ǻϤޤäƤ���кǽ�ιԤ򥹥��åפ��롣 ���äơ�chmod +x �� #! ������Ȥäơ� Lua������ץȤ�¹Բ�ǽ�ʥץ������ˤ��뤳�Ȥ��Ǥ��롣

#!/usr/local/bin/lua
(������󡢥��ߤΥޥ���Ǥ�Lua���󥿥ץ꥿�ϰ㤦���ˤ��뤫�⤷��ʤ��� �⤷ PATH ���̤�Ȥ����� lua ������С�
#!/usr/bin/env lua
�����ܿ����ι⤤���ˡ�Ǥ���)��



���С������Ȥ���ߴ�

�ץ�������Lua5.0����Lua5.1�˰ܹԤ���ݤ˸��Ĥ��뤫�⤷��ʤ���ߴ��ΰ����򼨤��� �ۤȤ�ɤ���ߴ���Ŭ�ڤʥ��ץ�����Ȥäƥ���ѥ��뤹�뤳�Ȥ��򤱤��� (�ե����� luaconf.h �򻲾�)�� �������ʤ��顢�����θߴ��ѥ��ץ����Ϥ��٤Ƽ��ΥС�������Lua�ǤϺ�������ͽ��Ǥ��롣

�С������5.0�Ȥ���ߴ�

������ѹ�

�饤�֥����ѹ�

API���ѹ�

Lua�δ����ʹ�ʸ

Lua�δ����ʹ�ʸ���ĥBNF��ˡ�Ǽ����� ����ϱ黻�Ҥ�ͥ���̤䡢 return ����� break ʸ���֥��å��� �Ǹ�� ʸ�Ȥ��Ƥ����Ȥ��ʤ��Ȥ��ä� �����Ĥ��ι�ʸŪ���¤ϵ��Ҥ��Ƥ��ʤ���


	chunk ::= {stat [`;��]} [laststat[`;��]]

	block ::= chunk

	stat ::=  varlist1 `=�� explist1  | 
		 functioncall  | 
		 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 explist1 do block end  | 
		 function funcname funcbody  | 
		 local function Name funcbody  | 
		 local namelist [`=�� explist1] 

	laststat ::= return [explist1]  |  break

	funcname ::= Name {`.�� Name} [`:�� Name]

	varlist1 ::= var {`,�� var}

	var ::=  Name  |  prefixexp `[�� exp `]��  |  prefixexp `.�� Name 

	namelist ::= Name {`,�� Name}

	explist1 ::= {exp `,��} exp

	exp ::=  nil  |  false  |  true  |  Number  |  String  |  `...��  | 
		 function  |  prefixexp  |  tableconstructor  |  exp binop exp  |  unop exp 

	prefixexp ::= var  |  functioncall  |  `(�� exp `)��

	functioncall ::=  prefixexp args  |  prefixexp `:�� Name args 

	args ::=  `(�� [explist1] `)��  |  tableconstructor  |  String 

	function ::= function funcbody

	funcbody ::= `(�� [parlist1] `)�� block end

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

	tableconstructor ::= `{�� [fieldlist] `}��

	fieldlist ::= field {fieldsep field} [fieldsep]

	field ::= `[�� exp `]�� `=�� exp  |  Name `=�� exp  |  exp

	fieldsep ::= `,��  |  `;��

	binop ::= `+��  |  `-��  |  `*��  |  `/��  |  `^��  |  `%��  |  `..��  | 
		 `<��  |  `<=��  |  `>��  |  `>=��  |  `==��  |  `~=��  | 
		 and  |  or

	unop ::= `-��  |  not  |  `#��


�ǽ�����: Tue Feb 21 11:17:28 BRT 2006