Copyright ��� 2006 Lua.org, PUC-Rio. All rights reserved.
����ʸ��ϡ� Lua 5.1 Reference Manual �����Ԥ�̵�Ǥ����ܸ����������������� Lua 5.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 �ȡ�
���Υ��������Ǥϡ�Lua�λ��硢��ʸ����̣���ˤĤ��Ƶ��Ҥ��롣 ����������ȡ����Υ��������Ǥϡ��ɤ����ä��ȡ�����ͭ������������ɤ��Ȥ߹�碌����Τ��������Ƥ����Ȥ߹�碌�ϲ����̣����Τ��ˤĤ��Ƶ��Ҥ��Ƥ��롣
���칽¤�ϰ���Ū�ʳ�ĥBNF��ˡ��Ȥä��������롣
{a} �� a ��0��ʾ�η����֤���[a] �� a ����ά��ǽ�Ǥ��뤳�Ȥ�ɽ����
��ü����� italic ��ɽ���졢������ɤ� bold��¾�ν�ü����ϥ��륯�����ȤǰϤޤ줿 type writer
�ե���Ȥ�ɽ������롣
Lua�δ����ʹ�ʸ�Ϥ��Υޥ˥奢��κǸ�ˤ��롣
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 �Τ褦�ʥ��������ץ�������ޤळ�Ȥ��Ǥ��롣
\a
--- �٥�
\b
--- �Хå����ڡ���
\f
--- ���ڡ���
\n
--- ����
\r
--- ����
\t
--- ��ʿ����
\v
--- ��ľ����
\\
--- �Хå�����å��� (�ߵ���)
\"
--- ������ (���֥륯������)
\'
--- ���ݥ��ȥ��ե� (���륯������)
�嵭�˲ä��ơ�
`\
������
(�Хå�����å������ʪ�β��Ԥ�³�������)
�Ҥ���ʸ������˲��Ԥ�ޤ�뤳�Ȥ��Ǥ��롣
����� `\
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
������ ��ʸ����γ��ʤ�ɤ��Ǥ⡢��ĤΥϥ��ե� (--
) �ǻϤ�뤳�Ȥ��Ǥ��롣
�⤷ --
��ľ��˳���Ĺ��̰ʳ��Υƥ����Ȥ�����С����Υ����Ȥ� û�������� �Ǥ��ꡢ�����ޤ�³����
�����Ǥʤ���С������ Ĺ�������� �Ǥ��ꡢ�б������Ĥ�Ĺ��̤ޤ�³����
Ĺ�������Ȥϥ����ɤ���Ū��̵���ˤ��뤿��ˤ褯�Ȥ��롣
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
��Ϳ����줿�ͤη���ɽ��ʸ������֤���
Lua��ʸ����ȿ��ͤ�¹Ի��˼�ưŪ���Ѵ����롣
���٤Ƥο��ر黻�ϡ�ʸ�����Ŭ�Ѥ����ȡ�����Ū���Ѵ��롼��˴�Ť��Ƥ���ʸ�������ͤ��Ѵ����褦�Ȥ��롣
�դˡ�ʸ�����Ԥ����Ȥ����ǿ��ͤ��Ȥ��ȡ����ο��ͤϰ���Ū�ʷ�����ʸ������Ѵ�����롣
���ͤ�ʸ������Ѵ��������ˡ�����˥���ȥ����뤹����ϡ�
ʸ����饤�֥��� format
�ؿ���Ȥ� (string.format
��)��
�ѿ����ͤ��Ǽ������Ǥ��롣 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���������Ƥ��ʤ���
����Ϥ��������Τ�����Ѥ��Ƥ�������Ǥ���)��
Lua��Pascal��C��Ʊ���褦�˰���Ū��ʸ�Υ��åȤݡ��Ȥ��Ƥ��롣 ���������湽¤���ؿ��ƤӽФ����ơ��֥륳�ȥ饯�����ѿ�������ʤɤǤ��롣
Lua�μ¹Ԥ�ñ�̤� ����� �ȸƤФ�롣 ����ϡ�ñ��ˡ����֤˼¹Ԥ����ʸ��Ϣ�ʤ�Ǥ��롣 ���줾���ʸ���ˤϾ�ά��ǽ�ʥ��ߥ�������֤��Ƥ��ɤ���
chunk ::= {stat [`;��]}��ʸ��¸�ߤ��ʤ����ᡢ`
;;
�� �ϵ�����Ƥ��ʤ���
Lua�ϥ�����ѸĤΰ��������̵̾�ؿ������ΤȤ��ư��äƤ��� (2.5.9 ��)�� ���äơ�����ϥ��������ѿ�������Ǥ��������������뤳�Ȥ��Ǥ�������ͤ��֤��롣
����ϥե������ۥ��ȥץ���������ʸ����Ȥ��Ƴ�Ǽ����Ƥ���Ǥ������� ������¹Ԥ����Ȥ����ޤ����ۥޥ����̿��˥���ѥ��뤵�졢���줫�饳��ѥ���Ѥߥ����ɤ����ۥޥ���Υ��ץ�ˤ�äƼ¹Ԥ���롣
����ϥХ��ʥ�����Υ���ѥ���Ѥߥ����ɤǤ��äƤ��ɤ���
�ܺ٤� luac
�ץ������ȡ�
�������ץ������ȥ���ѥ���Ѥ߷����Ϥɤ�����Ѥ��Ƥ��ɤ���
Lua�ϼ�ưŪ�˥ե���������Ф���Ŭ�ڤ˿�����
ʸ����ϥ֥��å��Ǥ��롣 ��ʸŪ�ˤϡ��֥��å��ϥ������������
block ::= chunk
�֥��å�������Ū��ñ���ʸ�Ȥ��뤳�Ȥ⤢�롣
stat ::= do block end
����Ū�ʥ֥��å����ѿ�����������פ�ȥ����뤹��Τ������Ǥ��롣 ����Ū�ʥ֥��å��Ϥޤ��� ¾�Υ֥��å�������� return ʸ�� break ʸ������뤿��˻Ȥ����Ȥ⤢�롣
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���������Ƥ��ʤ���
����Ϥ��������Τ�����Ѥ��Ƥ�������Ǥ���)��
���湽¤ 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 �� (����) �֥��å��κǸ��ʸ�ˤʤ롣
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
�ʲ�����������:
_var
��_limit
��_step
�ϸ����ʤ��ѿ��Ǥ��롣
����̾���������Τ�����Ѥ����Ƥ�������Ǥ��롣
var
�ϥ롼����ǥ�������Ǥ��롣
for ʸ�γ�¦�Ǥ����ͤ�Ȥ����ȤϤǤ��ʤ���
�⤷�롼���ѿ� var
���ͤ�ɬ�פʤ顢
�롼�פ�Ф������̤��ѿ�����������ɬ�פ����롣
���� 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
�ʲ�����������:
explist
�ϰ��٤���ɾ�����졢
���ƥ졼�� �ؿ��������������֤��ѿ� �ν���͡��Ǥʤ���Фʤ�ʤ���
_f
��_s
��_var
�ϸ����ʤ��ѿ��Ǥ��롣
����̾���������Τ�����Ѥ����Ƥ�������Ǥ��롣
var
�ϥ롼����ǥ�������Ǥ��롣
for ʸ�γ�¦�Ǥ����ͤ�Ȥ����ȤϤǤ��ʤ���
�⤷�롼���ѿ� var
���ͤ�ɬ�פʤ顢
�롼�פ�Ф������̤��ѿ�����������ɬ�פ����롣
�����Ѥ�����Ƥ��뤿�ᡢ�ؿ��ƤӽФ���ʸ�Ȥ��Ƽ¹ԤǤ��롣
stat ::= functioncall
���ξ�硢����ͤϤ��٤ƼΤƤ��롣 �ؿ��ƤӽФ��� 2.5.8 ���������롣
���������ѿ��ϥ֥��å�����ɤ��ǤǤ�����Ǥ��롣 ����Ͻ���ͤ�������ȼ�äƤ�褤��
stat ::= local namelist [`=�� explist1]
�⤷����С�¿��������Ʊ����ʸ�ǽ���ͤ���������� (2.4.3 ��)�� �����Ǥʤ���С��ѿ��Ϥ��٤� nil �ǽ��������롣
�����ޤ��֥��å��Ǥ��뤫�� (2.4.1 ��)�� ����Ū�ʥ֥��å��γ�¦�Υ���Ǥ���������ѿ�������Ǥ��롣 ���Τ褦�ʥ��������ѿ��Υ������פϥ���ν����ޤ�³����
���������ѿ��βĻ�롼��� 2.6 ���������롣
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 �Ȥʤ롣
Lua�ϰ���Ū�ʻ��ѱ黻�Ҥݡ��Ȥ��Ƥ��롣
+
(�û�)��
-
(����)��*
(�軻)��
/
(����)��%
(��;)��^
(�߾�)��
������ -
(���ȿž)��
�⤷���ڥ��ɤ����͡����뤤�Ͽ��ͤ��Ѵ��Ǥ���ʸ���� (2.2.1��)
�ʤ顢���٤Ƥα黻���̾�ΰ�̣����ġ�
�߾��Ǥ�դλؿ����Ф���ư��롣
�㤨�С�x^(-0.5)
�� x
��ʿ�����εտ�������롣
��;�ϰʲ��Τ褦���������Ƥ��롣
a % b == a - math.floor(a/b)*b�Ĥޤꡢ���̵����˸����äƴݤ��줿��껻��;��Ǥ��롣
Lua�δط��黻�Ҥϰʲ����̤�Ǥ��롣
== ~= < > <= >=
�����α黻�ҤϾ�� false �� true �����줫�η�̤��֤���
���� (==
) �Ϥޤ����ڥ��ɤη�����Ӥ��롣
�⤷�����ۤʤäƤ����顢��̤� false �Ǥ��롣
�����Ǥʤ���С����ڥ��ɤ��ͤ���Ӥ���롣
���ͤ�ʸ����ϰ���Ū����ˡ����Ӥ��롣
���֥������� (�ơ��֥롢�桼�����ǡ���������åɡ��ؿ�) �� ���� ����Ӥ���
2�ĤΥ��֥������Ȥ� Ʊ�� ���֥������ȤǤ�����������������Ȥߤʤ���
���������֥������� (�ơ��֥롢�桼�����ǡ������ؿ�) ���ä��Ȥ��Ͼ�ˡ�
���ο��������֥������Ȥϡ�������¸�ߤ��Ƥ������֥������ȤȰۤʤ롣
"eq"���åɤ�Ȥäơ��ơ��֥��桼�����ǡ�����Lua����Ӥ�����ˡ���Ѥ����� (2.8 ��)��
2.2.1 ���Ѵ��롼���������Ӥˤ�Ŭ�Ѥ���ʤ���
���Τ��ᡢ"0"==0
�� false ��ɾ�����졢
t[0]
�� t["0"]
�ϰۤʤä��ơ��֥륨��ȥ����
�黻�� ~=
���������� (==
) ������Ǥ��롣
�ط��黻�Ҥϼ��Τ褦��Ư���� ������ξ�����ͤʤ�С�������Ŭ�ڤ���Ӥ���롣 �⤷ξ���ΰ�����ʸ����ʤ�С����ߤΥ�������˽��äƤ����ͤ���Ӥ���롣�����Ǥʤ���С�Lua��"lt"�ޤ���"le"���åɤ��ߤ� (2.8 ��)��
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(���Υޥ˥奢��Ǥ� `
-->
�� �Ǽ��η�̤���)
Lua��ʸ����Ϣ��黻�ҤϤդ��ĤΥɥå� (`..
��) ��ɽ����
�⤷ξ���Υ��ڥ��ɤ�ʸ�����ͤʤ顢������ 2.2.1 �ǽҤ٤��롼��˽��ä�ʸ������Ѵ�����롣
�����Ǥʤ���С�"concat"���åɤ��ƤФ�� (2.8 ��)��
Ĺ���黻�Ҥ�ñ��黻�� #
��ɽ����롣
ʸ�����Ĺ���Ϥ��ΥХ��ȿ��Ǥ���
(�Ĥޤꡢ��ʸ����1�Х��Ȥ��Ȥ������Ρ�ʸ�����Ĺ���Ǥ���)��
�ơ��֥� t
��Ĺ���ϡ�
t[n]
�� nil �Ǥʤ� t[n+1]
�� nil �Ǥ���褦������ n
���������Ƥ��롣
�ޤ���t[1]
�� nil �ʤ� n
�ϥ����ˤʤꤦ�롣
nil �Ǥʤ��ͤ�1���� n
�ޤdz�Ǽ����Ƥ������̤�����Ǥϡ�
����Ĺ���ϺǸ�Υ���ǥå��� n
���������֤���
����ˡַ�פ�������
(�Ĥޤ�֤� nil ��������)��
#t
�Ϥɤ줫�� nil �ΤҤȤ������֤����⤷��ʤ�
(�Ĥޤꡢ���� nil ������ν����Ǥ���褦�˸�����Τ�)��
Lua�Ǥα黻�Ҥ�ͥ���̤�ʲ���ɽ�˼����� ͥ���̤��㤤��������
or and < > <= >= ~= == .. + - * / % not # - (unary) ^
�����̤�ˡ����å���ȤäƼ���ͥ���̤��Ѥ��뤳�Ȥ��Ǥ��롣
Ϣ�� (`..
��) ���߾� (`^
��) �ϱ����Ǥ��롣
¾�����黻�ҤϤ��٤ƺ����Ǥ��롣
�ơ��֥륳�ȥ饯���ϥơ��֥���뼰�Ǥ��롣 ���ȥ饯����ɾ������뤿�Ӥ˿������ơ��֥뤬����롣 ���Υơ��֥���뤳�Ȥ⡢�����Ĥ��Υե�����ɤ˽���ͤ���ä��ơ��֥���뤳�Ȥ�Ǥ��롣 ���ȥ饯���ι�ʸ�ϰʲ����̤�Ǥ��롣
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 ��)��
��ư���������ɤ������ʤ褦�ˡ��ƥե�����ɤν����˾�ά��ǽ�ʥ��ߥ�������դ��Ƥ��ɤ���
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�Ĥ�Ĵ�ᤵ��Ƥ���
�ؿ�����ι�ʸ��ʲ��˼�����
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
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
����ġ�
Lua���Ȥ߹��߳�ĥ����Ǥ��뤫�顢
���٤Ƥ�Lua���������ϥۥ��ȥץ�������C�Υ����ɤ�Lua�饤�֥��δؿ���Ƥ֤��Ȥˤ�äƥ������Ȥ���
(lua_pcall
��)��
Lua�Υ���ѥ������¹���ǥ��顼���������Ȥ��ϡ����椬C���֤��졢
Ŭ�ڤ�ư���Ԥ����Ȥ��Ǥ��� (�㤨�Х��顼��å�������Ф��Ȥ�)��
Lua�����ɤ� error
�ؿ���Ƥ֤��Ȥ�����Ū�˥��顼�������Ȥ��Ǥ��롣
�⤷Lua��ǥ��顼����館��ɬ�פ�����С�
pcall
�ؿ���Ȥ��Ф褤��
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 ���֤�)��
+
�黻��
�ʲ��� getbinhandler
�ؿ������黻��Lua���ɤΤ褦�˥ϥ�ɥ�����֤���������롣
�ޤ�Lua�Ϻǽ�Υ��ڥ��ɤˤĤ��ƻ�ߤ롣
�⤷���η��������α黻�ˤĤ��ƥϥ�ɥ��������Ƥ��ʤ���С�
�����ܤΥ��ڥ��ɤ��ߤ롣
function getbinhandler (op1, op2, event) return metatable(op1)[event] or metatable(op2)[event] end
���δؿ���Ȥä� op1 + op2
�ε�ư���ȡ�
function add_event (op1, op2) local o1, o2 = tonumber(op1), tonumber(op2) if o1 and o2 then -- ξ���Υ��ڥ��ɤ����ͤ�? return o1 + o2 -- ���� `+�� �ϥץ�ߥƥ��֤ʲû� else -- ���ʤ��Ȥ������Ͽ��ͤǤϤʤ� local h = getbinhandler(op1, op2, "__add") if h then -- ξ���Υ��ڥ��ɤ��Ф��ƥϥ�ɥ��Ƥ� return h(op1, op2) else -- �ϥ�ɥ餬�ʤ����ǥե���Ȥ�ư�� error("...") end end end
-
�黻��
"add"�黻��Ʊ���褦��ư��롣
*
�黻��
"add"�黻��Ʊ���褦��ư��롣
*
�黻��
"add"�黻��Ʊ���褦��ư��롣
%
�黻��
"add"�黻��Ʊ���褦��ư��롣
Behavior similar to the "add" operation,
�ץ�ߥƥ��ֱ黻�Ȥ��� o1 - floor(o1/o2)*o2
��Ȥ���
^
(�߾�) �黻��
"add"�黻��Ʊ���褦��ư��롣
�ץ�ߥƥ��ֱ黻�Ȥ��ƴؿ� pow
(C�ο��إ饤�֥��) ��Ȥ���
-
�黻��
function unm_event (op) local o = tonumber(op) if o then -- ���ڥ��ɤϿ��ͤ��� return -o -- ���� `-�� �ϥץ�ߥƥ��֤����ȿž else -- ���ڥ��ɤϿ��ͤǤʤ� -- ���ڥ��ɤ���ϥ�ɥ����Ф� local h = metatable(op).__unm if h then -- ���ڥ��ɤ��Ф��ƥϥ�ɥ��Ƥ� return h(op) else -- �ϥ�ɥ餬�ʤ����ǥե���Ȥ�ư�� error("...") end end end
..
(Ϣ��) �黻��
function concat_event (op1, op2) if (type(op1) == "string" or type(op1) == "number") and (type(op2) == "string" or type(op2) == "number") then return op1 .. op2 -- �ץ�ߥƥ���ʸ����Ϣ�� else local h = getbinhandler(op1, op2, "__concat") if h then return h(op1, op2) else error("...") end end end
#
�黻��
function len_event (op) if type(op) == "string" then return strlen(op) -- �ץ�ߥƥ��֤�ʸ����Ĺ elseif type(op) == "table" then return #op -- �ץ�ߥƥ��֤Υơ��֥�Ĺ else local h = metatable(op).__len if h then -- ���ڥ��ɤ��Ф��ƥϥ�ɥ��Ƥ� return h(op) else -- �ϥ�ɥ餬�ʤ����ǥե���Ȥ�ư�� error("...") end end end�ơ��֥��Ĺ���������� 2.5.5 �ȡ�
==
�黻��
�ؿ� getcomphandler
�ϡ���ӱ黻�ҤΥ��åɤ�Lua���ɤΤ褦�����֤���������롣
ξ���Υ��֥������Ȥ�Ʊ�����ǡ����α黻���Ф���Ʊ�����åɤ���ľ�������
���åɤ�����롣
function getcomphandler (op1, op2, event) if type(op1) ~= type(op2) then return nil end local mm1 = metatable(op1)[event] local mm2 = metatable(op2)[event] if mm1 == mm2 then return mm1 else return nil end end"eq"���٥�Ȥϼ��Τ褦���������롣
function eq_event (op1, op2) if type(op1) ~= type(op2) then -- �����ۤʤ뤫? return false -- �ۤʤ륪�֥������� end if op1 == op2 then -- �ץ�ߥƥ��֤Υ������� return true -- ���֥������Ȥ������� end -- ���åɤ� local h = getcomphandler(op1, op2, "__eq") if h then return h(op1, op2) else return false end end
a ~= b
�� not (a == b)
�������Ǥ��롣
<
�黻��
function lt_event (op1, op2) if type(op1) == "number" and type(op2) == "number" then return op1 < op2 -- ���ͤ���� elseif type(op1) == "string" and type(op2) == "string" then return op1 < op2 -- ��������� else local h = getcomphandler(op1, op2, "__lt") if h then return h(op1, op2) else error("..."); end end end
a > b
�� b < a
�������Ǥ���.
<=
�黻��
function le_event (op1, op2) if type(op1) == "number" and type(op2) == "number" then return op1 <= op2 -- ���ͤ���� elseif type(op1) == "string" and type(op2) == "string" then return op1 <= op2 -- ��������� else local h = getcomphandler(op1, op2, "__le") if h then return h(op1, op2) else h = getcomphandler(op1, op2, "__lt") if h then return not h(op2, op1) else error("..."); end end end end
a >= b
�� b <= a
�������Ǥ��롣
"le"���åɤ��ʤ���С�
Lua�� a <= b
�� not (b < a)
�Ȥߤʤ���"lt"���ߤ뤳�Ȥ����ա�
table[key]
����ǥå�������������
function gettable_event (table, key) local h if type(table) == "table" then local v = rawget(table, key) if v ~= nil then return v end h = metatable(table).__index if h == nil then return nil end else h = metatable(table).__index if h == nil then error("..."); end end if type(h) == "function" then return h(table, key) -- �ϥ�ɥ��Ƥ֤��� else return h[key] -- �黻���֤� end end
table[key] = value
����ǥå���������
function settable_event (table, key, value) local h if type(table) == "table" then local v = rawget(table, key) if v ~= nil then rawset(table, key, value); return end h = metatable(table).__newindex if h == nil then rawset(table, key, value); return end else h = metatable(table).__newindex if h == nil then error("..."); end end if type(h) == "function" then return h(table, key,value) -- �ϥ�ɥ��Ƥ֤��� else h[key] = value -- �黻���֤��� end end
function function_event (func, ...) if type(func) == "function" then return func(...) -- �ץ�ߥƥ��֤δؿ��ƤӽФ� else local h = metatable(func).__call if h then return h(func, ...) else error("...") end end end
����åɡ��ؿ����桼�����ǡ������Υ��֥������Ȥϡ� ��ơ��֥�˲ä��Ƥ⤦�ҤȤġ� ��Ϣ�դ����줿�ơ��֥����ġ� ����� �Ķ� �ȸƤ֡� ��ơ��֥�Ʊ�͡��Ķ������̤Υơ��֥�Ǥ��롣
�桼�����ǡ����˴�Ϣ�դ���줿�Ķ���Lua�ˤȤäƤϰ�̣������ʤ��� ����ϥץ�����ޤΤ���ˡ� �桼�����ǡ����˥ơ��֥���Ϣ�դ��뵡ǽ�Ȥ���¸�ߤ�������Ǥ��롣
����åɤ˴�Ϣ�դ���줿�Ķ��� �������Х�Ķ� �ȸƤ֡�
����ϡ�����åɤȡ�����åɤ���������
(loadfile
��loadstring
�ޤ��� load
��Ȥä�)
�ͥ��Ȥ���Ƥ��ʤ��ؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ�졢
C�Υ����ɤ�ľ�ܥ��������Ǥ��� (3.3 ��)��
C�δؿ��˴�Ϣ�դ���줿�Ķ���C�Υ����ɤ�ľ�ܥ��������Ǥ��� (3.3 ��)�� �ޤ����δؿ��Ǻ�������¾��C�δؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ��롣
Lua�δؿ��˴�Ϣ�դ���줿�Ķ��ϡ� ���δؿ�����ǥ����������륰�����Х��ѿ����褹�뤿��˻Ȥ��� (2.3 ��)�� �ޤ����δؿ��Ǻ�������¾��Lua�δؿ��Υǥե���ȤδĶ��Ȥ��ƻȤ��롣
setfenv
��Ƥ֤�������Υ���åɤ� Lua �δؿ��δĶ����ѹ��Ǥ��롣
getfenv
��Ƥ֤�������Υ���åɤ� Lua �δؿ��δĶ�������Ǥ��롣
¾�Υ��֥������� (�桼�����ǡ�����C�δؿ���¾�Υ���å�) �δĶ�������ˤϡ�C��API��Ȥ�ʤ���Фʤ�ʤ���
Lua�ϼ�ưŪ�˥����������롣 �Ĥޤꡢ���������֥������ȤΤ���Υ�����ݤ䡢���֥������Ȥ��פ�ʤ��ʤä��Ȥ��β����ˤĤ��ơ�Ǻ�ޤʤ��Ƥ褤�� Lua�ϻ������֥������� (�⤦���������Ǥ��ʤ��ʤä����֥�������) �������� ���١������쥯�� ������¹Ԥ��뤳�Ȥǡ���ưŪ�˥����������롣 �ơ��֥롢�桼�����ǡ������ؿ�������åɡ�ʸ����Ȥ��ä����٤Ƥ�Lua���֥������Ȥϼ�ư�������оݤǤ��롣
Lua�ϥ�����ޡ�������ɥ������ץ��쥯����������Ƥ��롣 ���١������쥯�����μ��������椹�뤿���2�Ĥο��͡� ���١������쥯������� �� ���١������쥯�����ƥå��� ��Ȥ����Ȥ��Ǥ��롣
���١������쥯������ͤϡ� �ɤ�����Фä��鿷������������Ϥ��뤫�����椹�롣 �ͤ��礭���ۤɥ��쥯�����ö�Ū�ˤʤ롣 1��꾮�����ͤˤ���ȡ����쥯���������˿�������������Ϥ��롣 2�ˤ���ȡ��Ȥ��Ƥ������ι�פ�2�ܤˤʤä��饳�쥯������������������Ϥ��롣
���ƥå����ϡ�������ݤ��Ф��륳�쥯��������®�٤����椹�롣 �ͤ��礭���ۤɥ��쥯�����Ѷ�Ū�ˤʤ뤬�� �ƥ����륹�ƥåפΥ��������礭���ʤ롣 1��꾮�����ͤˤ���ȡ����쥯���������٤��ʤꡢ��̤Ȥ��ƥ������뤬�����ʤ����⤷��ʤ��� �ǥե���Ȥ�2�Ǥϡ�������ݤΡ�2�ܡפ�®�٤ǥ��쥯����ư��롣
C�� lua_gc
��
Lua�� collectgarbage
��Ƥ֤ȡ��������ͤ��ѹ��Ǥ��롣
�������ѡ�������ͤǰ�������
(���ä� 100 ���Ϥ��� 1.00 ���̣����)��
�����δؿ��ǥ��쥯����ľ������Ǥ���
(��ߤ�������Ƴ���������)��
C��API��Ȥ���硢�桼�����ǡ����˥��١������쥯�����åɤ�����Ǥ��� (2.8��)�� ���Υ��åɤ� �ե����ʥ饤�� �ȸƤФ�뤳�Ȥ⤢�롣 �ե����ʥ饤����Lua�Υ��١������쥯������������ȶ��˻Ȥ���褦�ˤ��� (�ե������ͥåȥ����³���ǡ����١�����³�ʤɤ��Ĥ����ꡢ�ȼ��˳��ݤ���������������Ȥ�)��
��ơ��֥�� __gc
�ե�����ɤ���ĥ桼�����ǡ��������١����ˤʤäƤ⡢���١������쥯���Ϥ�����ˤϲ�����ʤ���
�������ꡢLua�Ϥ����ꥹ�Ȥ�����롣
¾�Υ��֥������Ȥβ��������ä����ȡ�Lua�ϥꥹ����Υ桼�����ǡ������Ф��ưʲ��δؿ���Ʊ���Τ��Ȥ�Ԥ���
function gc_event (udata) local h = metatable(udata).__gc if h then h(udata) end end
�ƥ��١������쥯���������ν����ˡ� ���줿�Ȥ��� �դν��֤� �桼�����ǡ����Υե����ʥ饤�����ƤФ�롣 �Ĥޤꡢ�ǽ�˸ƤФ��ե����ʥ饤���ϡ����ֺǶ�˺��줿�桼�����ǡ����Τ�ΤǤ��롣
�廲�ȥơ��֥� �� �廲�� �����Ǥ���ĥơ��֥�Ǥ��롣 �廲�Ȥϥ��١������쥯����̵�뤵��롣 ����������ȡ����֥������Ȥؤλ��Ȥ��廲�ȤΤߤǤ���С����١������쥯���Ϥ��Υ��֥������Ȥ������Ƥ��ޤ���
�廲�ȥơ��֥�ϡ��������͡����뤤�Ϥ���ξ�����廲�ȤǤ��롣
�廲�ȥ�������ĥơ��֥�ϡ������ϲ������뤬�������ͤϲ������ʤ���
�廲�ȥ����ȼ廲���ͤ�ξ������ĥơ��֥�Ǥϡ��������ͤ������оݤˤʤ롣
�������ͤΤɤ��餫��������������ȡ��������ͤΥڥ����Τ��ơ��֥뤫������롣
�ơ��֥�μ廲�Ȥ������ϡ���ơ��֥�� __mode
�ե�����ɤ�����Ǥ��롣
�⤷ __mode
�ե�����ɤ�ʸ����ǡ�ʸ�� `k
�� ���ޤޤ�Ƥ����顢�ơ��֥�Υ������廲�ȤȤʤ롣
�⤷ __mode
�ե�����ɤ�ʸ�� `v
�� ��ޤ�Ǥ����顢�ơ��֥���ͤ��廲�ȤȤʤ롣
��ơ��֥�Ȥ��ƻȤä���ˡ����Υơ��֥�� __mode
�ե�����ɤ��ͤ��ѹ�����٤��ǤϤʤ���
���Υ�ơ��֥�����椵��Ƥ���ơ��֥�μ廲�Ȥε�ư��̤����Ȥʤ롣
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
���Υ��������Ǥ�Lua�Τ����C��API���������롣
����ϡ��ۥ��ȥץ�����बLua��Ư�������뤿���C�δؿ��Υ��åȤǤ��롣
���٤Ƥ�API�ؿ��ȡ���Ϣ���뷿������ϡ��إå����ե����� lua.h
���������Ƥ��롣
���Υޥ˥奢��Ǥϡִؿ��פȤ������դ�Ȥ���������˥ޥ����Ȥ�������Ƥ����Τ⤢�롣 ���Τ褦�ʥޥ����Ϥ��٤ơ��ư��������礦�ɰ��٤���ɾ�����졢�����ʤ뱣�줿�����Ѥ�ȯ�����ʤ� (�������ǽ�ΰ���������������ˤϾ��Lua���ơ��Ȥ��Ϥ�)��
�ۤȤ�ɤ�C�Υ饤�֥���Ʊ�ͤˡ�
Lua��API�ؿ��ϰ�����������������������å����ʤ���
���������ե����� luaconf.h
����Υޥ��� luai_apicheck
��Ŭ�ڤ��������Lua��ƥ���ѥ��뤹��ȡ�����ư����ѹ��Ǥ��롣
Lua��C�Ȥδ֤��ͤ�����Ϥ����뤿��� ���ۥ����å� ��Ȥ��� �����å���γ����Ǥϡ�Lua���� (nil�����͡�ʸ����ʤ�) ��ɽ���Ƥ��롣
Lua��C��Ƥ֤Ȥ��ϡ������Υ����å��ξ��֤�ޤ������ƥ��֤�C�δؿ����ȤäƤ��륹���å��˱ƶ�����ʤ��褦�ˡ������������å����Ѱդ��롣
���Υ����å���C�δؿ����Ϥ��줿��������Ǽ����Ƥ��ꡢ
C�δؿ�����ƤӽФ�¦���֤�����ͤ��Ǽ���뤿��ˤ�Ȥ��� (lua_CFunction
��)��
�������Τ��ᡢ�ۤȤ�ɤ��䤤��碌��API�ؿ��ϸ�̩�ʥ����å��ε�§�˽��äƤ��ʤ���
����ˡ�����ǥå��� ��Ȥäơ������å����Ǥ�դ����Ǥ˥��������Ǥ��롣
�ץ饹�Υ���ǥå����ϥ����å���� ���� ���֤�ɽ�� (1 ����Ϥޤ�)��
�ޥ��ʥ��Υ���ǥå����ϥ����å��ȥåפ�������� ���ե��å� ��ɽ����
����Ū�˸����ȡ������å��� n �Ĥ����Ǥ�����Ȥ��ơ�
����ǥå���1�Ϻǽ������ (�Ĥޤꡢ���Υ����å��˺ǽ���Ѥޤ줿����) ��ɽ����
����ǥå��� n �ϺǸ�����Ǥ�ɽ����
����ǥå���-1��Ǹ������ (�Ĥޤꥹ���å��ȥåפˤ�������) ��ɽ����
����ǥå��� -n �Ϻǽ�����Ǥ�ɽ����
ͭ���� ����ǥå�����1���饹���å��ȥåפδ֤����Ǥ���
(�Ĥޤ� 1 <= abs(index) <= top
)��
Lua��API��Ȥ��Ȥ��ϡ���������ݾڤ�����Ǥ�����롣
�äˡ������å������С��ե����˵����դ��ʤ���Фʤ�ʤ���
�����å��������Ф�����ˤϴؿ� lua_checkstack
��Ȥ���
Lua��C��Ƥ֤Ȥ��ϡ�
����Ǥ����Τ� LUA_MINSTACK
�ĤΥ����å����Ǥ����Ѳ�ǽ�Ǥ��롣
LUA_MINSTACK
��20���������Ƥ��ꡢ
�����å��ˤɤ�ɤ����Ǥ��Ѥ�褦�ʥ롼�פ����ä��ꤷ�ʤ���С�
���̤ϥ����å����֤ˤ��ʤ��Ƥ��ɤ���
¿�����䤤��碌�ؿ��ˤϡ������å�����������Ѳ�ǽ��Ǥ�դΥ���ǥå����ͤ�Ȥ��롣
�Ĥޤꡢlua_checkstack
��Ȥä�����Ǥ�����祹���å���Ĺ���ޤǤΥ���ǥå����Ǥ��롣
���Τ褦�ʥ���ǥå����� ���������ǽ�ʥ���ǥå��� �ȸƤ֡�
��ä����Τˤϡ����������ǽ�ʥ���ǥå��� �ϰʲ��Τ褦���������롣
(index < 0 && abs(index) <= top) || (index > 0 && index <= stackspace)0�Ϸ褷�Ƽ��������ǽ�ʥ���ǥå����ˤʤ�ʤ���
�ä���������Ƥ��ʤ���С� �ɤδؿ��� ��������ǥå��� �ȸƤФ��ͭ���ʥ���ǥå���������դ��롣 ����ϥ����å����̵�������Ĥ���Lua���ͤ�C�Υ����ɤ��饢���������뤿��Τ�ΤǤ��롣 ��������ǥå����ϡ�����åɤδĶ����ؿ��δĶ����쥸���ȥꡢC�δؿ��ξ���ͤ˥����������뤿��˻Ȥ� (3.4 ��)��
����åɤδĶ� (�������Х��ѿ���������) �Ͼ�˵�������ǥå���
LUA_GLOBALSINDEX
�ΰ��֤ˤ��롣
�������C�δؿ��δĶ��Ͼ�˵�������ǥå���
LUA_ENVIRONINDEX
�ΰ��֤ˤ��롣
�������Х��ѿ����ͤ˥��������������ѹ����뤿��ˤϡ� �Ķ��ơ��֥���Ф������̤Υơ��֥�����Ԥ��� �㤨�С��������Х��ѿ����ͤ˥�����������ˤϰʲ���Ԥ���
lua_getfield(L, LUA_GLOBALSINDEX, varname);
C�δؿ����������Ȥ��������Ĥ����ͤ��Ϣ�դ��� C�Υ��������� ���뤳�Ȥ��Ǥ��롣
�������ͤ� ����� �ȸƤФ졢
���δؿ����ƤФ줿�Ȥ��ˤ��ĤǤ⥢�������Ǥ��롣
(lua_pushcclosure
��)��
C�δؿ����ƤФ��ȡ����̤ʵ�������ǥå����ˤ������ͤ����֤���롣
�����ε�������ǥå����ϥޥ��� lua_upvalueindex
����������롣
�ؿ��˴�Ϣ�դ���줿�ǽ���ͤ� lua_upvalueindex(1)
�ΰ��֤ˤ��ꡢ�Ĥ��Ʊ�ͤǤ��롣
���ߤδؿ��ξ���ͤο������礭�� n ��
lua_upvalueindex(n)
��ƤӽФ��Ƥ⡢
���������ǽ�� (������ͭ���Ǥʤ�) ����ǥå�������������롣
Lua�ϥ쥸���ȥ�����Ƥ��롣
���������ѤߤΥơ��֥�ǡ�������Lua���ͤ��Ǽ���뤿���C�Υ����ɤ���Ȥ����Ȥ��Ǥ��롣
���Υơ��֥�Ͼ�˵�������ǥå��� LUA_REGISTRYINDEX
���֤���Ƥ��롣
�ɤ�C�Υ饤�֥���ǡ������ݻ����뤿��ˤ��Υơ��֥��Ȥ��뤬��
���ͤ��뤿��¾�Υ饤�֥�꤬�ȤäƤ��ʤ�����������ɬ�פ����롣
ŵ��Ū�ˤϡ��饤�֥��̾��ޤ�ʸ����Ȥ�����ʬ�Υ����ɤǻȤäƤ���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�Υ��顼��ȯ�������뤳�Ȥ�����롣
�ʲ���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_GCSTOP
--- ���١������쥯������ߤ����롣
LUA_GCRESTART
--- ���١������쥯����Ƴ������롣
LUA_GCCOLLECT
--- �ե륬�١������쥯����������¹Ԥ��롣
LUA_GCCOUNT
--- Lua���ȤäƤ��븽�ߤΥ����̤� (�����Х��Ȥ�) �֤���
LUA_GCCOUNTB
--- Lua���ȤäƤ��븽�ߤΥ����̤ΥХ��ȿ���1024�dz�ä�;����֤���
LUA_GCSTEP
---
���١������쥯�����Υ����륹�ƥåפҤȤĤ�¹Ԥ��롣
���ƥåפΡ֥������פ� data
�����椹�롣
�礭���ͤ��礭�ʥ��ƥåפ��̣���뤬������Ū�ˤ���ޤäƤ��ʤ���
���ƥåץ����������椷������С�
data
���ͤ�¸�Ū��Ĵ�����ʤ���Фʤ�ʤ���
���Υ��ƥåפǥ��١������쥯��������뤬�����С����δؿ���1���֤���
LUA_GCSETPAUSE
---
���쥯���� ����� (see 2.10 ��)
�ο������ͤȤ��� data
��100�����ꤹ�롣
�ؿ��ϰ���������ͤ��֤���
LUA_GCSETSTEPMUL
---
���쥯���� ���ƥå��� (2.10 ��)
�ο������ͤȤ��� ����
��100�����ꤹ�롣
�ؿ��ϰ����Υ��ƥå������ͤ��֤���
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_ERRSYNTAX
---
����ѥ�����˹�ʸ���顼��ȯ����
LUA_ERRMEM
---
���������ƥ��顼��
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_ERRRUN
--- �¹Ի����顼��
LUA_ERRMEM
--- ������ݥ��顼��
���Τ褦�ʥ��顼�Ǥϡ�Lua�ϥ��顼�ϥ�ɥ�ؿ���ƤФʤ���
LUA_ERRERR
---
���顼�ϥ�ɥ�ؿ��¹���Υ��顼��
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
�˻��Ƥ��뤬�������Ĥ����פʰ㤤�����롣
`�������Ȥ��롣%%
�� (ʸ�� `%
��) `%s
�� (Ĺ�����¤Τʤ�������üʸ����) `%f
�� (lua_Number
) `%p
�� (16�ʿ��Ȥ��ƤΥݥ���) `%d
�� (int
) `%c
�� (ʸ���Ȥ��Ƥ�int
)
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
�����֤����������å�����ͤο��Ǥ��롣
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
�γƥե�����ɤϰʲ��Τ褦�ʰ�̣����äƤ��롣
source
---
�ؿ���ʸ�������������줿�ʤ�С�����ʸ����Ǥ��롣
�ؿ����ե��������������줿�ʤ�С�`@
�� �ǻϤޤꡢ���θ�˥ե�����̾��³����
short_src
---
���顼��å������˻Ȥ��ֲ��ɡץС������� source
��
linedefined
---
�ؿ�����γ��ϰ��֤ι��ֹ档
lastlinedefined
---
�ؿ�����ν�λ���֤ι��ֹ档
what
---
Lua�δؿ��ʤ� "Lua"
��
C�δؿ��ʤ� "C"
��
����Υᥤ�����Ǥ���� "main"
��
�ؿ�����ü�ƤӽФ������ʤ�� "tail"
��
�Ǹ�Υ������Ǥϡ�Lua�Ϥ��δؿ��ˤĤ���¾�˲��ξ������äƤ��ʤ���
currentline
---
���¹���ι��ֹ档
���ξ������Ѳ�ǽ�Ǥʤ���С�currentline
�� -1 �����ꤵ��롣
name
---
���δؿ����Ф���Ŭ����̾����
Lua�δؿ��ϥե������ȥ��饹���ͤǤ��뤿�ᡢ�����̾���ϻ��äƤ��ʤ���
ʣ���Υ������Х��ѿ��˳�Ǽ����Ƥ���ؿ��⤢��С��ơ��֥�ե�����ɤˤΤ߳�Ǽ����Ƥ����Τ⤢�롣
lua_getinfo
�ϡ����δؿ����ɤΤ褦�˸ƤФ줿����Ĵ�١��ɤ�������̾����õ����
̾�������Ĥ���ʤ���С�name
�� NULL
�����ꤵ��롣
namewhat
---
name
�ե�����ɤ��������롣
namewhat
�ϡ��ɤΤ褦�˴ؿ����ƤФ줿���ˤ�äơ��ʲ��Τ����줫�ˤʤ롣
"global"
, "local"
, "method"
,
"field"
, "upvalue"
, or ""
(��ʸ����¾��Ŭ���ʤ�Τ��ʤ���Ф����Ȥ�)��
nups
---
���δؿ��ξ���ͤο���
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
��ޤ�Ȥ�������̣����ġ�
���줾��Υ��٥�ȤˤĤ��ưʲ��ξ����ǥեå����ƤФ�롣
count
̿���¹Ԥ���ľ��˸ƤФ��
(���Υ��٥�Ȥ�Lua�δؿ���¹Ԥ��Ƥ���֤���������)��
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
���֤���
����饤�֥�� ��C��Lua�Υ��ե������Ȥʤ뤤���Ĥ��������ʴؿ������롣 ����API��C��Lua�����äδ���Ū�ʴؿ������뤬������饤�֥��Ϥ����Ĥ��ζ��̤κ�Ȥ���٥�ʴؿ������롣
����饤�֥��Τ��٤Ƥδؿ��ϥإå����ե����� lauxlib.h
��������졢��Ƭ�� luaL_
���դ��Ƥ��롣
����饤�֥��Τ��٤Ƥδؿ��ϴ���API�ξ�˹��ۤ���Ƥ��ꡢ���Τ��ᤳ��API�ǤǤ��ʤ����Ȥϲ������Ƥ��ʤ���
����饤�֥��ˤ�C�δؿ��ΰ���������å����뤿��δؿ��������Ĥ����롣
�����Ͼ�� luaL_check*
�ޤ��� luaL_opt*
�Ȥ���̾���Ǥ��롣
�����δؿ��ϥ����å�������(satisfied?)�Ǥʤ��ä��Ȥ����顼���������롣
���顼��å������ϰ����ǽ������ ("bad argument #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)���Ȥ�Ω�Ƥ�Τ˻Ȥ��� ����ϰʲ��Τ褦�˻��Ѥ��롣
luaL_Buffer
�����ѿ� b
��������롣
luaL_buffinit(L, &b)
��Ƥ�Ǥ�����������롣
luaL_add*
�ؿ��Τɤ줫��ȤäƥХåե���ʸ�����Ҥ��ɲä��롣
luaL_pushresult(&b)
��Ƥ֡�
����Ϻǽ�Ū��ʸ������å��ȥåפ˻Ĥ���
�̾�����Ƥ���֡�
ʸ����Хåե��Ϥ����Ĥ��Υ����å������åȤ�Ȥ���
���äƥХåե���ȤäƤ���֤ϡ������å��ȥåפ��ɤ��ˤ��뤫Ƚ�äƤ���Ȳ���Ǥ��ʤ���
�Хåե�����������(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�ϼ¹���δؿ��θƤӽФ����δؿ���
�ʲ�Ʊ�ͤǤ��롣
���δؿ��ϥ��顼��å���������Ƭ�����ۤ��뤿��˻Ȥ���
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
��Ȥä�
----
�ƤФʤ���Фʤ�ʤ���
���ܥ饤�֥���Lua�ؤΥ����ʵ�ǽ�����롣 ���ץꥱ�������ˤ��Υ饤�֥���ޤ�ʤ����ϡ����ε�ǽ����������μ������Ѱդ���ɬ�פ����뤫���Ť�Ĵ�٤�٤��Ǥ��롣
assert (v [, message])
v
���� (���ʤ�� nil �ޤ��� false) �Ǥ���Х��顼��ȯ�������롣
�����Ǥʤ���С����Τ��٤Ƥΰ������֤���
message
�ϥ��顼��å���������ꤹ�롣
��ά���줿���� "assertion failed!" �Ǥ��롣
collectgarbage (opt [, arg])
���δؿ��ϥ��١������쥯���ؤ����ѥ��ե������Ǥ��롣
�ǽ�ΰ��� opt
�ˤ�äưۤʤ뵡ǽ��¹Ԥ��롣
arg
�����椹�롣
�礭���ͤ��礭�ʥ��ƥåפ��̣���뤬������Ū�ˤ���ޤäƤ��ʤ���
���ƥåץ����������椷������С�
arg
���ͤ�¸�Ū��Ĵ�����ʤ���Фʤ�ʤ���
���Υ��ƥåפǥ��쥯��������뤬����ä����� true ���֤���
arg
��100�����ꤹ�롣
arg
��100�����ꤹ��
(2.10 ��)��
dofile (filename)
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
������ͤ��֤���
���롼�����Ϣ�����ϴ��ܥ饤�֥��Υ��֥饤�֥��Ǥ��ꡢ�ơ��֥� 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
�����ɲä�����ͤȤ����֤���롣
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
�ؤΥ��ץ����Ȥ��ƻȤ��롣
���Υ饤�֥��ϡ���������ʬʸ�������С��ѥ�����ޥå��Ȥ��ä���ʸ�������Τ���ΰ���Ū�ʵ�ǽ�����롣 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, ...)
ʸ�������ɤο��ͤϡ��ץ�åȥե������Ķ���Ƥβ��������ʤ����Ȥ����ա�
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, ...)
*
��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)
ʸ�����饹 ��ʸ���ν����ɽ���� �ʲ����Ȥ߹�碌��ʸ�����饹�λ���˻Ȥ����Ȥ��Ǥ��롣
^$()%.[]*+-?
�ʳ���ʸ��)
--- ʸ�� x ���켫�Ȥ�ɽ����
.
--- (�ɥå�) ���٤Ƥ�ʸ����ɽ����
%a
--- ���٤Ƥ�letter��ɽ����
%c
--- ���٤Ƥ�����ʸ����ɽ����
%d
--- ���٤Ƥο�����ɽ����
%l
--- ���٤Ƥξ�ʸ����ɽ����
%p
--- ���٤Ƥζ��ڤ국���ɽ����
%s
--- ���٤Ƥζ���ʸ����ɽ����
%u
--- ���٤Ƥ���ʸ����ɽ����
%w
--- ���٤Ƥαѿ�ʸ����ɽ����
%x
--- ���٤Ƥν�ϻ�ʿ�����ɽ����
%z
--- 0�Ȥ���ɽ�������ʸ����ɽ����
%x
(x �ϱѿ�ʸ���ʳ�) ---
ʸ�� x ���Ȥ�ɽ����
�������ˡ��ʸ���������פ���ɸ��Ū����ˡ�Ǥ��롣
�����ʤ���ڤ�ʸ�� (��ˡ��ʸ���Ǥʤ��Ƥ�) ������ `%�� ���դ��뤳�ȤǤ��켫�Ȥ�ɽ�����Ȥ��Ǥ��롣
[set]
---
set ��Τ��٤Ƥ�ʸ�����¤���ʤ륯�饹��ɽ����
������ʸ���� `-
�� �ǷҤ��뤳�Ȥǡ�ʸ�����ϰϤ�ɽ����
��ǵ� %
x �����Τ��٤ƤΥ��饹�⡢set ����ǻȤ����Ȥ��Ǥ��롣
����ʳ��� set ���ʸ���ϡ����켫�Ȥ�ɽ����
�㤨�С�[%w_]
(�ޤ��� [_%w]
) �ϡ����٤Ƥαѿ��˥��������������ä�����Τ�ɽ����
[0-7]
��Ȭ�ʿ�����ɽ����
[0-7%l%-]
��Ȭ�ʿ����Ⱦ�ʸ���� `-
�� ��ɽ����
�ϰϤȥ��饹����ߺ��Ѥ�̤����Ǥ��롣
�Ĥޤꡢ[%a-z]
�� [a-%%]
�Τ褦�ʥѥ�����ϰ�̣������ʤ���
[^set]
---
set ���佸���ɽ����
set �����ƤϾ������������Τ�Ʊ���Ǥ��롣
%a
��%c
�ʤ�) �Ϥ��٤ơ��б�������ʸ�����佸���ɽ����
�㤨�� %S
�϶���ʳ��Τ��٤Ƥ�ʸ����ɽ����
ʸ����������¾��ʸ���Υ��롼�פ�����ˤĤ��Ƥϡ����ߤΥ�������˰�¸���롣
�äˡ����饹 [a-z]
�� %l
�������ǤϤʤ����⤷��ʤ���
�ѥ���������� �ϰʲ��Τ����줫�Ǥ��롣
*
�� ��³������Ρ�
���Υ��饹��ʸ����0��ʾ�η����֤��˥ޥå����롣
���η����֤����Ǥϡ���ǽ�ʸ¤�Ĺ���������˥ޥå����롣
+
�� ��³������Ρ�
���Υ��饹��ʸ����1��ʾ�η����֤��˥ޥå����롣
���η����֤����Ǥϡ���ǽ�ʸ¤�Ĺ���������˥ޥå����롣
-
�� ��³������Ρ�
���Υ��饹��ʸ����0��ʾ�η����֤��˥ޥå����롣
`*
�� �Ȱۤʤꡢ���η����֤����Ǥϲ�ǽ�ʸ¤� û�� �������˥ޥå����롣
?
�� ��³������Ρ�
���Υ��饹��ʸ����0��ޤ���1��νи��˥ޥå����롣
%
n (n ��1����9)��
����ϡ�n ���ܤ˥���ץ��㤵�줿ʸ����˥ޥå�����褦�����ǤǤ��� (����������)��
%b
xy (x �� y �ϰۤʤ�ʸ��)��
����� x �ǻϤޤä� y �ǽ����ʸ����˥ޥå�����褦�����ǤǤ��롣
x �� y �� ���������
�Ĥޤꡢʸ������鱦���ɤ�Ǥ��äơ�
x ������뤿�Ӥ˥�����Ȥ� +1 ����y �Ǥ� -1 �����Ȥ���
�Ǹ�� y �ϥ�����Ȥ�0�ˤʤ�ǽ�� y �Ǥ��롣
�㤨�С����� %b()
�ϥ��å����б�����줿���˥ޥå����롣
pattern �ϥѥ��������Ǥ���Ǥ��롣
�ѥ�����κǽ�˸���� `^
�� ���о�ʸ�������Ƭ�˥ޥå�����ꤹ�롣
�ѥ�����κǸ�˸���� `$
�� ���о�ʸ����κǸ�˥ޥå�����ꤹ�롣
¾�ΰ��֤Ǥϡ�`^
�� �� `$
�� �����̤ʰ�̣������������켫�Ȥ�ɽ����
�ѥ�����ϥ��å��ǰϤޤ줿���֥ѥ��������Ĥ��Ȥ��Ǥ��������� ����ץ��� �ȸƤФ�롣
�ޥå������������Ȥ����о�ʸ�������ǥ���ץ���˥ޥå�������ʬ����¸ (����ץ���) ���졢��ǻȤ����Ȥ��Ǥ��롣
����ץ���Ϥ��κ����å��ˤ�ä��ֹ��դ�����롣
�㤨�С��ѥ����� "(a*(.)%w(%s*))"
�Ǥϡ�
"a*(.)%w(%s*)"
�˥ޥå�������ʬ���ǽ�Υ���ץ���Ȥ�����¸���� (������1�֤ˤʤ�)��
"."
�˥ޥå�����ʸ����2�֤˥���ץ��㤵�졢
"%s*"
�˥ޥå�������ʬ��3�֤ˤʤ롣
�ü�ʥ������Ȥ��ơ�������ץ��� ()
��ʸ����θ��߰��� (����) ��ץ��㤹�롣
�㤨�С�ʸ���� "flaaap"
�˥ѥ����� "()aa()"
��Ŭ�Ѥ���ȡ�
2�ĤΥ���ץ���3��5�������롣
�ѥ�����ˤ�����˥�����ޤळ�Ȥ��Ǥ��ʤ�������� %z
��Ȥ���
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�α黻�� <
������˻Ȥ��롣
�����ȤΥ��르�ꥺ��ϰ����Ǥʤ��� �Ĥޤꡢ���ꤵ�줿����ˤ������������ȹͤ��������Ǥϡ������Ȥˤ�äƤ������а��֤��Ѥ�뤫�⤷��ʤ���
���Υ饤�֥���ɸ��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
�ؿ��ϵ������ȯ����Ρ֥������͡פ����ꤹ�롣
Ʊ���������ͤ����Ʊ��������������롣
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�Ĥ��롣
flush
������� (5.7 ��))
�����Ԥ��롣
sizes
�ǥХåե��Υ�������Х���ñ�̤ǻ���Ǥ��롣
�ǥե���ȤΥ�������Ŭ���Ǥ��롣
file:write (value1, ...)
�����Τ��줾����ͤ� file
�˽��ࡣ
������ʸ�������Ǥʤ���Фʤ�ʤ���
����ʳ����ͤ����ˤϡ�
write
������ tostring
�� string.format
��Ȥ���
���Υ饤�֥��ϥơ��֥� os
���̤�������롣
os.clock ()
�ץ�����ब�Ȥä�CPU���֤γ����ͤ��ä��֤���
os.date ([format [, time]])
Ϳ����줿ʸ���� format
�˽��äƽ��������դȻ����ޤ�ʸ���ޤ��ϥơ��֥���֤���
time
������¸�ߤ���С����줬����������Ȥʤ�
(�����ͤ������� os.time
�ؿ���)��
�����Ǥʤ���С�date
�ϸ����������롣
format
�� `!
�� �ǻϤޤäƤ����顢
���դ������� (Universal Time) �ǽ�����롣
���Υ��ץ����ʸ���θ塢
format
�� *t
�Ǥ���С�
date
�ϰʲ��Υե�����ɤ���ĥơ��֥���֤���
year
(4����)
month
(1--12)
day
(1--31)
hour
(0--23)
min
(0--59)
sec
(0--61)
wday
(��������������1)
yday
(1��1���������������)
isdst
(�ƻ��֤��ե饰���֡��ꥢ��)
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 ()
�ƥ�ݥ��ե�����Ȥ��ƻȤ���ե�����̾���֤��� ���Υե�����ϻȤ���������Ū�˥����ץ�ɬ�פ����ꡢ �פ�ʤ��ʤä�������Ū�˺蘆�ʤ���Фʤ�ʤ���
���Υ饤�֥���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�ϰʲ���ʸ������ʤ롣
"c"
--- �եå���Lua���ؿ���Ƥ֤��Ӥ˸ƤФ�롣
"r"
--- �եå���Lua���ؿ�������뤿�Ӥ˸ƤФ�롣
"l"
--- �եå���Lua�������ɤο������Ԥ����뤿�Ӥ˸ƤФ�롣
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
�Ȱ��˻Ȥ��롣
Lua��C�Υۥ��ȥץ��������Ȥ߹��ޤ���ĥ����Ȥ��ƥǥ����줿�ˤ�ؤ�餺��
������ɥ�����θ���Ȥ��Ƥ�褯�Ȥ��롣
������ɥ�����θ���Ȥ��Ƥ�Lua���ץ�ϡ�ñ��� lua
�ȸƤФ졢
ɸ��Υǥ����ȥ�ӥ塼�����ȶ�������Ƥ��롣
������ɥ�����Υ��ץ�ϡ�
�ǥХå��饤�֥���ޤह�٤Ƥ�ɸ��饤�֥�����äƤ��롣
�Ȥ����ϰʲ����̤ꡣ
lua [options] [script [args]]���ץ����ϰʲ����̤ꡣ
-
�ե����������� stdin
����¹Ԥ��롣
-e
stat ʸ���� stat ��¹Ԥ��롣
-l
mod mod �� "requires" ���롣
-i
script ��¹Ԥ����塢���å⡼�ɤ����롣
-v
�С������������Ϥ��롣
--
���ץ����ν�����ߤ�롣
-
���ץ����ν�����ߤᡢstdin
��ե�����Ȥ��Ƽ¹Ԥ��롣
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�ǤϺ�������ͽ��Ǥ��롣
arg
����
���Ѱ��������ѹ����줿��
(luaconf.h
�Υ��ץ���� LUA_COMPAT_VARARG
)
[[...]]
) �ϥͥ��ȤǤ��ʤ��ʤä���
���ξ�硢��������ʸ ([=[...]=]
) ��Ȥ����Ȥ��Ǥ��롣
(luaconf.h
�Υ��ץ���� LUA_COMPAT_LSTR
)
string.gfind
�� string.gmatch
��̾�����ѹ����줿��
(���ץ���� LUA_COMPAT_GFIND
)
string.gsub
��3���ܤΰ����˴ؿ����Ϥ�����硢
���δؿ��� nil �ޤ��� false ���֤��ȡ�
��ʸ����Ǥʤ��ޥå�����ʸ�������Τ��ִ�����褦�ˤʤä���
table.setn
���ѻߤ��줿��
�ؿ� table.getn
�Ͽ�����Ĺ���黻�� (#
) ���б����롣
�ؿ�������˱黻�Ҥ�Ȥ���
(���ץ���� LUA_COMPAT_GETN
)
loadlib
�� package.loadlib
��̾�����ѹ����줿��
(���ץ���� LUA_COMPAT_LOADLIB
)
math.mod
�� math.fmod
��̾�����ѹ����줿��
(���ץ���� LUA_COMPAT_MOD
)
table.foreach
����� table.foreachi
���ѻߤ��줿��
�롼�פˤ������ pairs
�ޤ��� ipairs
��Ȥ���
require
���������ѹ����Ԥ�줿��
�������ʤ��顢������ư��ϰ����Ȥܸۤߴ��������롣
������ require
�� LUA_PATH
�������
package.path
����ѥ���������롣
collectgarbage
�ΰ������ѹ����줿��
�ؿ� gcinfo
���ѻߤ��줿��
����� collectgarbage("count")
��Ȥ���
luaopen_*
�ؿ����̾��C�δؿ��Τ褦�ˤ�ľ�ܤϸƤ٤ʤ��ʤä���
������Lua�δؿ��Τ褦��Lua���̤��ƸƤФʤ���Фʤ�ʤ���
lua_open
�ϡ��桼���ȼ��Υ�����ݴؿ������Ǥ��� lua_newstate
���֤�������줿��
ɸ��Υ�����ݴؿ� (realloc
��١����Ȥ���) ��Ȥäƥ��ơ��Ȥ���ˤϡ�
ɸ��饤�֥��� luaL_newstate
��Ȥ���
luaL_getn
����� luaL_setn
(����饤�֥��ˤ��ä�) ���ѻߤ��줿��
luaL_getn
������� lua_objlen
��Ȥ���
luaL_setn
�������¸�ߤ��ʤ���
luaL_openlib
�� luaL_register
���֤�������줿��
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 | `#��