Lua 5.4 リファレンスマニュアル

著：Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes

Copyright © 2020–2023 Lua.org, PUC-Rio. Luaライセンスの条項に基づき自由に使用できます。

1 – はじめに

Luaは、強力で、効率的で、軽量で、組み込み可能なスクリプト言語です。手続き型プログラミング、オブジェクト指向プログラミング、関数型プログラミング、データ駆動型プログラミング、およびデータ記述をサポートしています。

Luaは、単純な手続き型構文と、連想配列と拡張可能なセマンティクスに基づいた強力なデータ記述構造を組み合わせています。Luaは動的型付けであり、レジスタベースの仮想マシンでバイトコードを解釈して実行し、世代別ガベージコレクションによる自動メモリ管理を備えているため、構成、スクリプト作成、および迅速なプロトタイピングに最適です。

Luaは、標準CとC++の共通サブセットであるクリーンCで記述されたライブラリとして実装されています。Luaディストリビューションには、Luaライブラリを使用して完全なスタンドアロンのLuaインタープリターを提供するホストプログラムluaが含まれており、対話型またはバッチで使用できます。Luaは、強力で軽量で組み込み可能なスクリプト言語として、あらゆるプログラムで必要とされるものとして、また、強力で軽量かつ効率的なスタンドアロン言語として使用することを目的としています。

拡張言語として、Luaには「メイン」プログラムという概念はありません。これは、埋め込みプログラムまたは単にホストと呼ばれるホストクライアントに埋め込まれて動作します。（多くの場合、このホストはスタンドアロンのluaプログラムです。）ホストプログラムは、関数を呼び出してLuaコードを実行したり、Lua変数を書き込んだり読み取ったり、C関数を登録してLuaコードから呼び出すことができます。C関数を使用することで、Luaはさまざまなドメインに対応するように拡張でき、構文フレームワークを共有するカスタマイズされたプログラミング言語を作成できます。

Luaはフリーソフトウェアであり、そのライセンスに記載されているように、通常、保証なしで提供されます。このマニュアルで説明されている実装は、Luaの公式ウェブサイトwww.lua.orgで入手できます。

他のリファレンスマニュアルと同様に、このドキュメントは場所によっては退屈です。Luaの設計の背後にある決定に関する議論については、Luaのウェブサイトで入手できる技術論文を参照してください。Luaでのプログラミングの詳細な入門については、Robertoの著書「Programming in Lua」を参照してください。

2 – 基本概念

このセクションでは、言語の基本概念について説明します。

2.1 – 値と型

Luaは動的型付け言語です。これは、変数には型がなく、値にのみ型があることを意味します。言語に型定義はありません。すべての値は独自の型を持ちます。

Luaのすべての値は、第一級の値です。これは、すべての値を変数に格納したり、他の関数に引数として渡したり、結果として返したりできることを意味します。

Luaには、nil、boolean、number、string、function、userdata、thread、tableの8つの基本型があります。型nilには、他の任意の値とは異なることを主な特性とする単一の値nilがあります。これは、しばしば有用な値の欠如を表します。型booleanには、falseとtrueの2つの値があります。nilとfalseの両方が条件を偽にします。これらは総称して偽の値と呼ばれます。その他の任意の値は条件を真にします。名前にもかかわらず、falseは、nilの代替としてよく使用されます。主な違いは、falseがテーブル内の通常の値のように振る舞うのに対し、テーブル内のnilは欠落したキーを表すことです。

型numberは、integerとfloatの2つのサブタイプを使用して、整数と実数（浮動小数点）数の両方を表します。標準のLuaは、64ビット整数と倍精度（64ビット）浮動小数点を使用しますが、32ビット整数および/または単精度（32ビット）浮動小数点を使用するようにLuaをコンパイルすることもできます。整数と浮動小数点の両方に32ビットを使用するオプションは、小型マシンや組み込みシステムにとって特に魅力的です。（ファイルluaconf.hのマクロLUA_32BITSを参照してください。）

特に明記しない限り、整数値を操作する際のオーバーフローは、通常の2の補数演算の規則に従って折り返されます。（言い換えれば、実際の結果は、数学的結果に対して2ⁿを法とする等しい、表現可能な一意の整数です。ここで、nは整数型のビット数です。）

Luaには、各サブタイプがいつ使用されるかについての明示的な規則がありますが、必要に応じて自動的に変換も行われます（§3.4.3を参照）。したがって、プログラマーは、整数と浮動小数点の違いをほとんど無視するか、各数値の表現を完全に制御することを選択できます。

型stringは、不変のバイトシーケンスを表します。Luaは8ビットクリーンです。文字列には、埋め込みゼロ（'\0'）を含む任意の8ビット値を含めることができます。Luaはエンコーディングにも依存しません。文字列の内容に関する仮定は行いません。Luaの任意の文字列の長さは、Lua整数に収まる必要があります。

Luaは、Luaで記述された関数とCで記述された関数を呼び出し（および操作）できます（§3.4.10を参照）。どちらも型functionで表されます。

型userdataは、任意のCデータをLua変数に格納できるようにするために提供されています。userdata値は、生のメモリのブロックを表します。userdataには、2つの種類があります。フルuserdataは、Luaが管理するメモリブロックを持つオブジェクトであり、ライトuserdataは、単にCポインター値です。userdataには、Luaでの割り当てと同一性テストを除いて、定義済みの操作はありません。メタテーブルを使用することにより、プログラマーはフルuserdata値の操作を定義できます（§2.4を参照）。userdata値はLuaで作成または変更することはできず、C APIでのみ可能です。これにより、ホストプログラムおよびCライブラリが所有するデータの整合性が保証されます。

型threadは、独立した実行スレッドを表し、コルーチンを実装するために使用されます（§2.6を参照）。Luaスレッドは、オペレーティングシステムのスレッドとは関係ありません。Luaは、ネイティブでスレッドをサポートしていないシステムでも、すべてのシステムでコルーチンをサポートします。

型tableは、連想配列を実装します。つまり、インデックスとして数値だけでなく、nilおよびNaNを除く任意のLua値を持つことができる配列です。（Not a Numberは、0/0などの未定義の数値結果を表すためにIEEE 754標準で使用される特別な浮動小数点値です。）テーブルは異種にすることができます。つまり、すべての型（nilを除く）の値を含めることができます。値nilに関連付けられているキーは、テーブルの一部とは見なされません。逆に、テーブルの一部ではないキーには、関連付けられた値nilがあります。

テーブルはLuaの唯一のデータ構造メカニズムです。これらは、通常の配列、リスト、シンボルテーブル、セット、レコード、グラフ、ツリーなどを表すために使用できます。レコードを表すために、Luaはフィールド名をインデックスとして使用します。言語は、a.nameをa["name"]の糖衣構文として提供することにより、この表現をサポートしています。Luaでテーブルを作成するには、いくつかの便利な方法があります（§3.4.9を参照）。

インデックスと同様に、テーブルフィールドの値は任意の型にできます。特に、関数は第一級の値であるため、テーブルフィールドには関数を含めることができます。したがって、テーブルはメソッドも持つことができます（§3.4.11を参照）。

テーブルのインデックス作成は、言語の生の等価性の定義に従います。a[i]とa[j]という式は、iとjが生の等しい（つまり、メタメソッドなしで等しい）場合にのみ、同じテーブル要素を示します。特に、整数値を持つ浮動小数点数は、それぞれの整数と等しくなります（例：1.0 == 1）。あいまいさを回避するために、整数と等しいキーとして使用される浮動小数点数は、その整数に変換されます。たとえば、a[2.0] = trueと記述した場合、テーブルに挿入される実際のキーは整数2になります。

テーブル、関数、スレッド、（フル）userdata値はオブジェクトです。変数は、これらの値を実際には含まず、それらへの参照のみを含みます。割り当て、パラメーター渡し、関数の戻り値は、常にこのような値への参照を操作します。これらの操作は、いかなる種類のコピーも意味しません。

ライブラリ関数typeは、指定された値の型を記述する文字列を返します（typeを参照）。

2.2 – 環境とグローバル環境

§3.2および§3.3.3でさらに説明するように、自由名（つまり、宣言にバインドされていない名前）varへの参照はすべて、構文的に_ENV.varに変換されます。さらに、すべてのチャンクは_ENVという名前の外部ローカル変数のスコープでコンパイルされるため（§3.3.2を参照）、_ENV自体はチャンク内の自由名になることはありません。

この外部の_ENV変数と自由名の変換が存在するにもかかわらず、_ENVは完全に通常の名前です。特に、その名前で新しい変数とパラメーターを定義できます。自由名への各参照は、Luaの通常の可視性規則に従って、プログラムのその時点で可視である_ENVを使用します（§3.5を参照）。

_ENVの値として使用されるテーブルはすべて、環境と呼ばれます。

Luaは、グローバル環境と呼ばれる特別な環境を保持します。この値は、Cレジストリの特別なインデックスに保持されます（§4.3を参照）。Luaでは、グローバル変数_Gはこの同じ値で初期化されます。（_Gは内部で使用されないため、その値を変更しても、自分のコードにのみ影響します。）

Luaがチャンクをロードすると、その_ENV変数のデフォルト値はグローバル環境になります（loadを参照）。したがって、デフォルトでは、Luaコード内の自由名はグローバル環境のエントリを参照するため、グローバル変数とも呼ばれます。さらに、すべての標準ライブラリはグローバル環境にロードされ、そこにある一部の関数はその環境で動作します。load（またはloadfile）を使用して、別の環境でチャンクをロードできます。（Cでは、チャンクをロードしてから、最初のアップバリューの値を変更する必要があります。lua_setupvalueを参照してください。）

2.3 – エラー処理

Luaのいくつかの操作は、エラーを発生させる可能性があります。エラーはプログラムの通常の流れを中断しますが、エラーをキャッチすることで続行できます。

Luaコードは、error関数を呼び出すことで、明示的にエラーを発生させることができます。（この関数は決して戻りません。）

Luaでエラーをキャッチするには、pcall（またはxpcall）を使用して、保護された呼び出しを行うことができます。関数pcallは、指定された関数を保護モードで呼び出します。関数の実行中にエラーが発生すると、実行が停止し、制御はすぐにpcallに戻り、pcallはステータスコードを返します。

Luaは埋め込み拡張言語であるため、Luaコードはホストプログラム内のCコードからの呼び出しによって実行を開始します。（Luaをスタンドアロンで使用する場合、luaアプリケーションがホストプログラムです。）通常、この呼び出しは保護されています。したがって、Luaチャンクのコンパイルまたは実行中に、保護されていないエラーが発生すると、制御はホストに戻り、ホストはエラーメッセージの出力などの適切な対策を講じることができます。

エラーが発生すると、エラーに関する情報を含むエラーオブジェクトが伝播されます。Lua自体はエラーオブジェクトが文字列であるエラーのみを生成しますが、プログラムは任意の値を持つエラーオブジェクトを生成できます。そのようなエラーオブジェクトを処理するのは、Luaプログラムまたはそのホストの責任です。歴史的な理由から、エラーオブジェクトは文字列である必要はないにもかかわらず、しばしばエラーメッセージと呼ばれます。

xpcall (またはCではlua_pcall) を使用する場合、エラーが発生した場合に呼び出されるメッセージハンドラを指定できます。この関数は、元のエラーオブジェクトで呼び出され、新しいエラーオブジェクトを返します。スタックがアンワインドされる前に呼び出されるため、スタックを検査したり、スタックトレースバックを作成したりするなど、エラーに関する詳細情報を収集できます。このメッセージハンドラは、保護された呼び出しによって引き続き保護されています。したがって、メッセージハンドラ内のエラーは、メッセージハンドラを再度呼び出します。このループが長すぎると、Luaはループを中断し、適切なメッセージを返します。メッセージハンドラは、通常実行時のエラーに対してのみ呼び出されます。メモリ割り当てエラーや、ファイナライザーまたはその他のメッセージハンドラの実行中のエラーに対しては呼び出されません。

Luaは、警告のシステムも提供しています ( warn を参照)。エラーとは異なり、警告はプログラムの実行を妨げることはありません。通常、ユーザーにメッセージを生成するだけですが、この動作はCから適応させることができます ( lua_setwarnf を参照)。

2.4 – メタテーブルとメタメソッド

Luaのすべての値は、メタテーブルを持つことができます。このメタテーブルは、特定のイベント下で元の値の動作を定義する通常のLuaテーブルです。メタテーブルに特定のフィールドを設定することで、値の動作のいくつかの側面を変更できます。たとえば、数値以外の値が加算のオペランドである場合、Luaは値のメタテーブルの__addフィールドの関数をチェックします。見つかった場合、Luaはこの関数を呼び出して加算を実行します。

メタテーブル内の各イベントのキーは、イベント名の前に2つのアンダースコアが付いた文字列です。対応する値はメタ値と呼ばれます。ほとんどのイベントの場合、メタ値は関数である必要があり、その関数はメタメソッドと呼ばれます。前の例では、キーは文字列"__add"であり、メタメソッドは加算を実行する関数です。特に断りのない限り、メタメソッドは実際には任意の呼び出し可能な値であり、それは関数または__callメタメソッドを持つ値のいずれかです。

getmetatable関数を使用して、任意の値のメタテーブルをクエリできます。Luaは、生のアクセス（rawgetを参照）を使用してメタテーブル内のメタメソッドをクエリします。

setmetatable関数を使用して、テーブルのメタテーブルを置き換えることができます。デバッグライブラリ (§6.10) を使用する場合を除き、Luaコードから他の型のメタテーブルを変更することはできません。

複数のテーブルやユーザーデータがメタテーブルを共有できますが、テーブルとフルユーザーデータは個別のメタテーブルを持ちます。他のすべての型の値は、型ごとに1つのメタテーブルを共有します。つまり、すべての数値に1つのメタテーブル、すべての文字列に1つのメタテーブルなどがあります。デフォルトでは、値はメタテーブルを持ちませんが、文字列ライブラリは文字列型にメタテーブルを設定します ( §6.4 を参照)。

メタテーブルによって制御される操作の詳細なリストを次に示します。各イベントは、対応するキーによって識別されます。慣例により、Luaで使用されるすべてのメタテーブルキーは、2つのアンダースコアに続けて小文字のラテン文字で構成されています。

• __add: 加算 (+) 操作。加算のオペランドが数値でない場合、Luaはメタメソッドを呼び出そうとします。まず最初のオペランドをチェックします（それが数値であっても）。そのオペランドが__addのメタメソッドを定義していない場合、Luaは2番目のオペランドをチェックします。Luaがメタメソッドを見つけることができる場合、Luaは2つのオペランドを引数としてメタメソッドを呼び出し、呼び出しの結果（1つの値に調整）が操作の結果になります。それ以外の場合、メタメソッドが見つからないと、Luaはエラーを発生させます。
• __sub: 減算 (-) 操作。加算操作と同様の動作。
• __mul: 乗算 (*) 操作。加算操作と同様の動作。
• __div: 除算 (/) 操作。加算操作と同様の動作。
• __mod: モジュロ (%) 操作。加算操作と同様の動作。
• __pow: 指数 (^) 操作。加算操作と同様の動作。
• __unm: 否定 (単項 -) 操作。加算操作と同様の動作。
• __idiv: 床除算 (//) 操作。加算操作と同様の動作。
• __band: ビット単位 AND (&) 操作。加算操作と同様の動作ですが、オペランドが整数でも整数に強制変換可能な浮動小数点数でもない場合、Luaはメタメソッドを試行します (§3.4.3を参照)。
• __bor: ビット単位 OR (|) 操作。ビット単位AND操作と同様の動作。
• __bxor: ビット単位排他的 OR (バイナリ ~) 操作。ビット単位AND操作と同様の動作。
• __bnot: ビット単位 NOT (単項 ~) 操作。ビット単位AND操作と同様の動作。
• __shl: ビット単位左シフト (<<) 操作。ビット単位AND操作と同様の動作。
• __shr: ビット単位右シフト (>>) 操作。ビット単位AND操作と同様の動作。
• __concat: 連結 (..) 操作。加算操作と同様の動作ですが、オペランドが文字列でも数値でもない場合（常に文字列に強制変換可能）、Luaはメタメソッドを試行します。
• __len: 長さ (#) 操作。オブジェクトが文字列でない場合、Luaはそのメタメソッドを試行します。メタメソッドがある場合、Luaはオブジェクトを引数として呼び出し、呼び出しの結果（常に1つの値に調整）が操作の結果になります。メタメソッドはないが、オブジェクトがテーブルの場合、Luaはテーブルの長さの操作を使用します (§3.4.7を参照)。それ以外の場合、Luaはエラーを発生させます。
• __eq: 等しい (==) 操作。加算操作と同様の動作ですが、比較対象の値がテーブルまたはフルユーザーデータであり、原始的に等しくない場合にのみ、Luaはメタメソッドを試行します。呼び出しの結果は常にブール値に変換されます。
• __lt: より小さい (<) 操作。加算操作と同様の動作ですが、比較対象の値が数値でも文字列でもない場合にのみ、Luaはメタメソッドを試行します。さらに、呼び出しの結果は常にブール値に変換されます。
• __le: 以下 (<=) 操作。より小さい操作と同様の動作。
• __index: インデックスアクセス操作 table[key]。このイベントは、tableがテーブルではない場合、またはkeyがtableに存在しない場合に発生します。メタ値は、tableのメタテーブルで検索されます。

  このイベントのメタ値は、関数、テーブル、または__indexメタ値を持つ任意の値のいずれかです。関数である場合は、tableとkeyを引数として呼び出され、呼び出しの結果（1つの値に調整）が操作の結果になります。それ以外の場合、最終的な結果は、このメタ値をkeyでインデックス付けした結果です。このインデックス付けは生ではなく、通常どおりに行われるため、別の__indexメタ値をトリガーする可能性があります。

• __newindex: インデックス割り当て table[key] = value。インデックスイベントと同様に、このイベントは、tableがテーブルではない場合、またはkeyがtableに存在しない場合に発生します。メタ値は、tableのメタテーブルで検索されます。

  インデックス付けと同様に、このイベントのメタ値は、関数、テーブル、または__newindexメタ値を持つ任意の値のいずれかです。関数である場合、table、key、およびvalueを引数として呼び出されます。それ以外の場合、Luaはこのメタ値に対して、同じキーと値を使用してインデックス割り当てを繰り返します。この割り当ては生ではなく、通常どおりに行われるため、別の__newindexメタ値をトリガーする可能性があります。

  __newindexメタ値が呼び出されるたびに、Luaは原始的な割り当てを実行しません。必要な場合、メタメソッド自体がrawsetを呼び出して割り当てを行うことができます。

• __call: 呼び出し操作 func(args)。このイベントは、Luaが関数以外の値 (つまり、funcが関数ではない) を呼び出そうとした場合に発生します。メタメソッドは、funcで検索されます。存在する場合、メタメソッドは、最初の引数としてfuncを、その後に元の呼び出しの引数 (args) を付けて呼び出されます。呼び出しのすべての結果が操作の結果です。これは、複数の結果を許可する唯一のメタメソッドです。

前のリストに加えて、インタープリターはメタテーブルで次のキーも尊重します。__gc ( §2.5.3 を参照)、__close ( §3.3.8 を参照)、__mode ( §2.5.4 を参照)、および __name (__nameエントリが文字列を含む場合、tostring およびエラーメッセージで使用される場合があります)。

単項演算子（否定、長さ、ビット単位NOT）の場合、メタメソッドは計算され、最初のオペランドと等しいダミーの2番目のオペランドを使用して呼び出されます。この追加のオペランドは、Luaの内部を簡略化するためだけに使用され (これらの演算子をバイナリ演算のように動作させる)、将来のバージョンでは削除される可能性があります。ほとんどの場合、この追加のオペランドは無関係です。

メタテーブルは通常のテーブルであるため、上記で定義したイベント名だけでなく、任意のフィールドを含めることができます。標準ライブラリの一部の関数 (例: tostring) は、独自の目的のためにメタテーブルの他のフィールドを使用します。

一部のオブジェクトのメタテーブルとして設定する前に、必要なすべてのメタメソッドをテーブルに追加することをお勧めします。特に、__gcメタメソッドは、この順序に従う場合にのみ機能します ( §2.5.3 を参照)。オブジェクトのメタテーブルは、作成直後に設定することをお勧めします。

2.5 – ガベージコレクション

Luaは自動メモリ管理を実行します。これは、新しいオブジェクトのメモリを割り当てることや、オブジェクトが不要になったときにメモリを解放することを心配する必要がないことを意味します。Luaは、ガベージコレクターを実行してすべてのデッドオブジェクトを収集することにより、メモリを自動的に管理します。Luaで使用されるすべてのメモリは、自動管理の対象となります。文字列、テーブル、ユーザーデータ、関数、スレッド、内部構造などです。

オブジェクトは、ガベージコレクタが、プログラムの通常の実行においてそのオブジェクトが再びアクセスされないと確信できるとすぐに、デッドと見なされます。（ここでいう「通常の実行」には、デッドオブジェクトを復活させる可能性のあるファイナライザ（§2.5.3を参照）や、デバッグライブラリを使用した操作は含まれません。）コレクタがオブジェクトがデッドであると確信できるタイミングは、プログラマーの期待と一致しない場合があることに注意してください。保証されているのは、Luaがプログラムの通常の実行においてまだアクセスされる可能性のあるオブジェクトを収集しないこと、そしてLuaからアクセスできないオブジェクトは最終的に収集されるということです。（ここでいうLuaからアクセスできないとは、変数も他の生存しているオブジェクトもそのオブジェクトを参照していないことを意味します。）LuaはCコードに関する知識を持っていないため、グローバル環境（§2.2参照）を含むレジストリ（§4.3参照）を通してアクセスできるオブジェクトを収集することはありません。

Luaのガベージコレクタ（GC）は、インクリメンタルモードとジェネレーショナルモードの2つのモードで動作できます。

デフォルトのパラメータを使用したデフォルトのGCモードは、ほとんどの用途に適しています。しかし、メモリの割り当てと解放に多くの時間を費やしているプログラムでは、他の設定が役立つ場合があります。GCの動作は、プラットフォーム間および異なるLuaリリース間で移植性がないことに注意してください。したがって、最適な設定も移植性がないことになります。

GCモードとパラメータは、C言語ではlua_gcを呼び出すことで、Luaではcollectgarbageを呼び出すことで変更できます。これらの関数を使用して、コレクタを直接制御することもできます（例えば、停止や再起動）。

2.5.1 – インクリメンタルガベージコレクション

インクリメンタルモードでは、各GCサイクルは、プログラムの実行とインターリーブされた小さなステップでマークアンドスイープコレクションを実行します。このモードでは、コレクタは3つの数値を使用して、ガベージコレクションサイクルを制御します。すなわち、ガベージコレクタの一時停止、ガベージコレクタのステップ乗数、およびガベージコレクタのステップサイズです。

ガベージコレクタの一時停止は、コレクタが新しいサイクルを開始するまでに待機する時間を制御します。コレクタは、メモリの使用量が前のコレクション後の使用量のn%に達すると、新しいサイクルを開始します。値が大きいほど、コレクタの積極性が低くなります。100以下の値は、コレクタが新しいサイクルを開始するのを待たないことを意味します。200の値は、コレクタが使用中のメモリの合計が2倍になるのを待ってから新しいサイクルを開始することを意味します。デフォルト値は200です。最大値は1000です。

ガベージコレクタのステップ乗数は、メモリ割り当てに対するコレクタの速度を制御します。つまり、メモリが1キロバイト割り当てられるごとに、いくつの要素をマークまたはスイープするかです。値が大きいほど、コレクタの積極性が高まりますが、インクリメンタルステップのサイズも大きくなります。100未満の値は、コレクタが遅くなりすぎるため、コレクタがサイクルを完了しない可能性があるため、使用しないでください。デフォルト値は100です。最大値は1000です。

ガベージコレクタのステップサイズは、各インクリメンタルステップのサイズを制御します。具体的には、インタプリタがステップを実行する前に何バイト割り当てるかです。このパラメータは対数的です。値nは、インタプリタがステップ間で2ⁿバイトを割り当て、ステップ中に同等の作業を実行することを意味します。大きな値（例えば60）は、コレクタをストップザワールド（非インクリメンタル）コレクタにします。デフォルト値は13で、これは約8キロバイトのステップを意味します。

2.5.2 – ジェネレーショナルガベージコレクション

ジェネレーショナルモードでは、コレクタは頻繁にマイナーコレクションを実行し、これは最近作成されたオブジェクトのみを走査します。マイナーコレクションの後でもメモリの使用量が制限を超えている場合、コレクタはすべてのオブジェクトを走査するストップザワールドのメジャーコレクションを実行します。ジェネレーショナルモードでは、マイナー乗数とメジャー乗数の2つのパラメータを使用します。

マイナー乗数は、マイナーコレクションの頻度を制御します。マイナー乗数xの場合、新しいマイナーコレクションは、メモリが前のメジャーコレクション後の使用量よりもx%大きくなると実行されます。たとえば、乗数が20の場合、コレクタは、メモリの使用量が前のメジャーコレクション後の使用量よりも20％大きくなると、マイナーコレクションを実行します。デフォルト値は20です。最大値は200です。

メジャー乗数は、メジャーコレクションの頻度を制御します。メジャー乗数xの場合、新しいメジャーコレクションは、メモリが前のメジャーコレクション後の使用量よりもx%大きくなると実行されます。たとえば、乗数が100の場合、コレクタは、メモリの使用量が前のコレクション後の使用量の2倍を超えると、メジャーコレクションを実行します。デフォルト値は100です。最大値は1000です。

2.5.3 – ガベージコレクションメタメソッド

テーブルに対して、またC APIを使用して、フルユーザデータに対してガベージコレクションメタメソッドを設定できます（§2.4を参照）。これらのメタメソッドは、ファイナライザと呼ばれ、対応するテーブルまたはユーザデータがデッドであるとガベージコレクタが検出したときに呼び出されます。ファイナライザを使用すると、ファイル、ネットワーク、またはデータベース接続のクローズや独自のメモリの解放など、Luaのガベージコレクションを外部リソース管理と連携させることができます。

収集時にファイナライズされるオブジェクト（テーブルまたはユーザデータ）にするには、ファイナライズ対象としてマークする必要があります。オブジェクトのメタテーブルを設定し、そのメタテーブルに__gcメタメソッドがある場合に、オブジェクトをファイナライズ対象としてマークします。__gcフィールドなしでメタテーブルを設定し、後でそのフィールドをメタテーブルに作成した場合、オブジェクトはファイナライズ対象としてマークされないことに注意してください。

マークされたオブジェクトがデッドになると、ガベージコレクタによってすぐに収集されるわけではありません。代わりに、Luaはそれをリストに入れます。コレクション後、Luaはそのリストを調べます。リスト内の各オブジェクトについて、Luaはそのオブジェクトの__gcメタメソッドをチェックします。存在する場合、Luaはオブジェクトを単一の引数として渡してそれを呼び出します。

各ガベージコレクションサイクルの終わりに、ファイナライザは、そのサイクルで収集されたオブジェクトのうち、プログラムで最後にマークされたオブジェクトに関連付けられたものが最初に呼び出されるという逆順で呼び出されます。各ファイナライザの実行は、通常のコードの実行中の任意の時点で発生する可能性があります。

収集されているオブジェクトはファイナライザによってまだ使用されている必要があるため、そのオブジェクト（およびそれを通してのみアクセス可能な他のオブジェクト）はLuaによって復活される必要があります。通常、この復活は一時的なものであり、オブジェクトのメモリは次のガベージコレクションサイクルで解放されます。ただし、ファイナライザがオブジェクトをグローバルな場所（例えば、グローバル変数）に格納する場合、復活は永続的になります。さらに、ファイナライザがファイナライズ対象のオブジェクトを再びファイナライズ対象としてマークした場合、そのファイナライザは、オブジェクトがデッドである次のサイクルで再び呼び出されます。いずれにしても、オブジェクトのメモリが解放されるのは、オブジェクトがデッドであり、ファイナライズ対象としてマークされていないGCサイクルでのみです。

状態を閉じるとき（lua_closeを参照）、Luaは、マークされた順序の逆順に従って、ファイナライズ対象としてマークされたすべてのオブジェクトのファイナライザを呼び出します。この段階で、ファイナライザが収集対象としてオブジェクトをマークした場合、これらのマークは効果がありません。

ファイナライザは、yieldしたり、ガベージコレクタを実行したりすることはできません。それらは予測不可能な時間に実行される可能性があるため、各ファイナライザを、関連付けられたリソースを適切に解放するために必要な最小限の操作に制限することをお勧めします。

ファイナライザの実行中にエラーが発生すると、警告が生成されます。エラーは伝播されません。

2.5.4 – ウィークテーブル

ウィークテーブルは、その要素がウィーク参照であるテーブルです。ウィーク参照は、ガベージコレクタによって無視されます。言い換えれば、オブジェクトへの参照がウィーク参照のみである場合、ガベージコレクタはそのオブジェクトを収集します。

ウィークテーブルは、ウィークキー、ウィーク値、またはその両方を持つことができます。ウィーク値を持つテーブルは、その値のコレクションを許可しますが、キーのコレクションを防ぎます。ウィークキーとウィーク値の両方を持つテーブルは、キーと値の両方のコレクションを許可します。いずれの場合も、キーまたは値のいずれかが収集されると、ペア全体がテーブルから削除されます。テーブルの弱さは、メタテーブルの__modeフィールドによって制御されます。このメタ値が存在する場合、以下のいずれかの文字列である必要があります。ウィークキーを持つテーブルの場合は "k"、ウィーク値を持つテーブルの場合は "v"、ウィークキーとウィーク値の両方を持つテーブルの場合は "kv" です。

ウィークキーとストロング値を持つテーブルは、エフェメロンテーブルとも呼ばれます。エフェメロンテーブルでは、値は、そのキーが到達可能な場合にのみ到達可能と見なされます。特に、キーへの唯一の参照がその値を介して行われている場合、ペアは削除されます。

テーブルの弱さの変更は、次の収集サイクルでのみ有効になる場合があります。特に、弱さをより強いモードに変更した場合、変更が有効になる前に、Luaがそのテーブルから一部の項目を収集する可能性があります。

明示的な構築を持つオブジェクトのみがウィークテーブルから削除されます。数値やライトC関数などの値は、ガベージコレクションの対象ではないため、ウィークテーブルから削除されません（関連付けられた値が収集されない限り）。文字列はガベージコレクションの対象ですが、明示的な構築がなく、その等価性は値によって行われるため、オブジェクトよりも値のように動作します。したがって、それらはウィークテーブルから削除されません。

復活したオブジェクト（つまり、ファイナライズ中のオブジェクト、およびファイナライズ中のオブジェクトを通してのみアクセス可能なオブジェクト）は、ウィークテーブルで特別な動作をします。それらはファイナライザを実行する前にウィーク値から削除されますが、ウィークキーからは、それらのオブジェクトが実際に解放される、ファイナライザの実行後の次のコレクションでのみ削除されます。この動作により、ファイナライザはウィークテーブルを介してオブジェクトに関連付けられたプロパティにアクセスできます。

ウィークテーブルがコレクションサイクルで復活したオブジェクトに含まれている場合、次のサイクルまで適切にクリアされない可能性があります。

2.6 – コルーチン

Luaは、協調的マルチスレッディングとも呼ばれるコルーチンをサポートしています。Luaにおけるコルーチンは、独立した実行スレッドを表します。ただし、マルチスレッドシステムのスレッドとは異なり、コルーチンは明示的にyield関数を呼び出すことによってのみ実行を中断します。

coroutine.createを呼び出すことによってコルーチンを作成します。唯一の引数は、コルーチンのメイン関数である関数です。create関数は新しいコルーチンを作成し、そのハンドル（thread型のオブジェクト）を返すだけで、コルーチンを開始しません。

coroutine.resumeを呼び出すことによってコルーチンを実行します。coroutine.resumeを最初に呼び出す際に、coroutine.createによって返されたスレッドを最初の引数として渡すと、コルーチンはそのメイン関数を呼び出すことによって実行を開始します。coroutine.resumeに渡された追加の引数は、その関数への引数として渡されます。コルーチンの実行が開始されると、コルーチンは終了するか、yieldするまで実行を続けます。

コルーチンは、次の2つの方法で実行を終了できます。1つは、メイン関数が（最後の命令の後、明示的または暗黙的に）戻るときに正常に終了する方法と、もう1つは、保護されていないエラーが発生した場合に異常終了する方法です。正常終了の場合、coroutine.resumeはtrueと、コルーチンのメイン関数から返された値を返します。エラーの場合、coroutine.resumeはfalseとエラーオブジェクトを返します。この場合、コルーチンはスタックを巻き戻さないため、デバッグAPIを使用してエラー後にスタックを検査できます。

コルーチンは、coroutine.yieldを呼び出すことによってyieldします。コルーチンがyieldすると、対応するcoroutine.resumeは、yieldがネストされた関数呼び出し内（つまり、メイン関数ではなく、メイン関数によって直接的または間接的に呼び出された関数内）で発生した場合でも、直ちに返ります。yieldの場合、coroutine.resumeはtrueと、coroutine.yieldに渡された値を返します。次回同じコルーチンを再開すると、coroutine.yieldへの呼び出しが、coroutine.resumeに渡された追加の引数を返すことで、yieldした場所から実行を継続します。

coroutine.createと同様に、coroutine.wrap関数もコルーチンを作成しますが、コルーチン自体を返す代わりに、呼び出されるとコルーチンを再開する関数を返します。この関数に渡された引数は、coroutine.resumeへの追加の引数として渡されます。coroutine.wrapは、coroutine.resumeによって返されたすべての値を、最初の値（ブールエラーコード）を除いて返します。coroutine.resumeとは異なり、coroutine.wrapによって作成された関数は、エラーを呼び出し元に伝播します。この場合、関数はコルーチンも閉じます（coroutine.closeを参照）。

コルーチンの動作例として、次のコードを考えてみましょう

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

これを実行すると、次の出力が生成されます

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

C APIを介してコルーチンを作成および操作することもできます。関数lua_newthread、lua_resume、およびlua_yieldを参照してください。

3 – 言語

このセクションでは、Luaの語彙、構文、および意味について説明します。言い換えれば、このセクションでは、どのトークンが有効か、それらをどのように組み合わせることができるか、およびそれらの組み合わせが何を意味するかについて説明します。

言語構成は、通常の拡張BNF表記を使用して説明されます。{a}は0個以上のaを意味し、[a]はオプションのaを意味します。非終端記号は非終端記号のように表示され、キーワードはkwordのように表示され、その他の終端記号は「=」のように表示されます。Luaの完全な構文は、このマニュアルの最後に§9にあります。

3.1 – 字句規則

Luaは自由形式の言語です。2つのトークン間の区切り文字として以外は、字句要素（トークン）間のスペースとコメントを無視します。ソースコードでは、Luaは標準ASCII空白文字（スペース、改ページ、改行、復帰、水平タブ、垂直タブ）をスペースとして認識します。

Luaの名前（識別子とも呼ばれる）は、ラテン文字、アラビア数字、およびアンダースコアで構成される任意の文字列で、数字で始まらず、予約語でないものであれば使用できます。識別子は、変数、テーブルフィールド、およびラベルに名前を付けるために使用されます。

次のキーワードは予約されており、名前として使用することはできません。

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

Luaは大文字と小文字を区別する言語です。andは予約語ですが、AndとANDは2つの異なる有効な名前です。慣例として、プログラムはアンダースコアと1つ以上の大文字（_VERSIONなど）で始まる名前の作成を避ける必要があります。

次の文字列は、他のトークンを示します

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

短いリテラル文字列は、一致する単一引用符または二重引用符で区切ることができ、次のCのようなエスケープシーケンスを含めることができます。 '\a' (ベル)、'\b' (バックスペース)、'\f' (改ページ)、'\n' (改行)、'\r' (復帰)、'\t' (水平タブ)、'\v' (垂直タブ)、'\\' (バックスラッシュ)、'\"' (引用符 [二重引用符])、および '\'' (アポストロフィ [単一引用符])。バックスラッシュの後に改行が続くと、文字列内の改行になります。エスケープシーケンス '\z' は、改行を含む後続の空白文字スパンをスキップします。これは、文字列の内容に改行やスペースを追加せずに、長いリテラル文字列を複数行に分割してインデントするのに特に役立ちます。短いリテラル文字列には、エスケープされていない改行や、有効なエスケープシーケンスを形成しないエスケープを含めることはできません。

埋め込まれたゼロを含む、短いリテラル文字列内の任意のバイトを、その数値で指定できます。これは、エスケープシーケンス \xXX（XXは2つの16進数）またはエスケープシーケンス \ddd（dddは最大3つの10進数）を使用して行うことができます。（10進数のエスケープシーケンスの後に数字が続く場合は、正確に3桁で表現する必要があることに注意してください。）

Unicode文字のUTF-8エンコードは、エスケープシーケンス\u{XXX}（必須の括弧で囲む）を使用してリテラル文字列に挿入できます。ここで、XXXは文字コードポイントを表す1つ以上の16進数です。このコードポイントは、2³¹未満の値にすることができます。（Luaはここで元のUTF-8仕様を使用しており、有効なUnicodeコードポイントに限定されません。）

リテラル文字列は、長い括弧で囲まれた長い形式を使用して定義することもできます。レベルnの開始長い括弧を、左角括弧の後にn個の等号が続き、その後に別の左角括弧が続くものとして定義します。したがって、レベル0の開始長い括弧は[[と記述され、レベル1の開始長い括弧は[=[と記述されます。終了長い括弧も同様に定義されます。たとえば、レベル4の終了長い括弧は]====]と記述されます。長いリテラルは、任意のレベルの開始長い括弧で始まり、同じレベルの最初の終了長い括弧で終わります。同じレベルの終了括弧を除く任意のテキストを含めることができます。この括弧形式のリテラルは、複数行にまたがることができ、エスケープシーケンスを解釈せず、他のレベルの長い括弧を無視します。あらゆる種類の行末シーケンス（復帰、改行、復帰に続く改行、または改行に続く復帰）は、単純な改行に変換されます。開始長い括弧の直後に改行が続く場合、その改行は文字列に含まれません。

例として、ASCIIを使用するシステム（ 'a' が97、改行が10、 '1' が49としてコード化されている）では、以下の5つのリテラル文字列は同じ文字列を表します

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

前の規則によって明示的に影響を受けないリテラル文字列内の任意のバイトは、それ自身を表します。ただし、Luaは解析のためにテキストモードでファイルを開き、システムのファイル関数は一部の制御文字で問題が発生する可能性があります。したがって、バイナリデータは、テキスト以外の文字に対して明示的なエスケープシーケンスを使用する引用符付きリテラルとして表現する方が安全です。

数値定数（または数詞）は、オプションの小数部と、文字 'e' または 'E' でマークされたオプションの10進指数で記述できます。Luaは、0xまたは0Xで始まる16進定数も受け入れます。16進定数は、オプションの小数部と、文字 'p' または 'P' でマークされ、10進数で記述されたオプションのバイナリ指数も受け入れます。（たとえば、0x1.fp10は1984を示し、これは0x1f / 16に2¹⁰を乗じたものです。）

基数点または指数を持つ数値定数は浮動小数点数を表します。それ以外の場合、その値が整数に適合するか、16進定数である場合は、整数を表します。それ以外の場合（つまり、オーバーフローする10進数の整数）、浮動小数点数を表します。基数点も指数もない16進数は常に整数値を表します。値がオーバーフローすると、有効な整数に収まるようにラップアラウンドします。

有効な整数定数の例を次に示します

     3   345   0xff   0xBEBADA

有効な浮動小数点定数の例を次に示します

     3.0     3.1416     314.16e-2     0.31416E1     34e1
     0x0.1E  0xA23p-4   0X1.921FB54442D18P+1

コメントは、文字列の外側の任意の場所で二重ハイフン（--）で始まります。--の直後のテキストが開始長い括弧でない場合、コメントは短いコメントであり、行末まで実行されます。それ以外の場合、長いコメントであり、対応する終了長い括弧まで実行されます。

3.2 – 変数

変数は値を格納する場所です。Luaには、グローバル変数、ローカル変数、およびテーブルフィールドの3種類の変数があります。

単一の名前は、グローバル変数またはローカル変数（または、ローカル変数の特定の種類の関数の仮パラメータ）を表すことができます。

	var ::= Name

名前は識別子を示します（§3.1を参照）。

明示的にローカルとして宣言されない限り、すべての変数名はグローバルであるとみなされます（§3.3.7参照）。ローカル変数はレキシカルスコープを持ちます。ローカル変数は、そのスコープ内で定義された関数から自由にアクセスできます（§3.5参照）。

変数への最初の代入が行われる前、その値はnilです。

角括弧は、テーブルのインデックス付けに使用されます。

	var ::= prefixexp ‘[’ exp ‘]’

テーブルフィールドへのアクセスは、メタテーブルを介して意味を変更できます（§2.4参照）。

構文var.Nameは、var["Name"]のシンタックスシュガーです。

	var ::= prefixexp ‘.’ Name

グローバル変数xへのアクセスは、_ENV.xと同等です。チャンクのコンパイル方法により、変数_ENV自体は決してグローバルではありません（§2.2参照）。

3.3 – ステートメント

Luaは、他の一般的な言語と同様の、ほぼ従来のステートメントセットをサポートしています。このセットには、ブロック、代入、制御構造、関数呼び出し、変数宣言が含まれます。

3.3.1 – ブロック

ブロックはステートメントのリストであり、順次実行されます。

	block ::= {stat}

Luaには、ステートメントをセミコロンで区切ったり、セミコロンでブロックを開始したり、セミコロンを2つ続けて記述したりできる、空のステートメントがあります。

	stat ::= ‘;’

関数呼び出しと代入の両方が、開き括弧で始まることができます。この可能性は、Luaの文法にあいまいさを生じさせます。次のフラグメントを考えてみましょう。

     a = b + c
     (print or io.write)('done')

文法は、このフラグメントを2つの方法で見ることができます。

     a = b + c(print or io.write)('done')
     
     a = b + c; (print or io.write)('done')

現在のパーサーは、常にこのような構造を最初の方法で見て、開き括弧を呼び出しの引数の開始として解釈します。このあいまいさを避けるために、括弧で始まるステートメントの前には常にセミコロンを付けるのが良い習慣です。

     ;(print or io.write)('done')

ブロックを明示的に区切って、単一のステートメントを作成できます。

	stat ::= do block end

明示的なブロックは、変数宣言のスコープを制御するのに役立ちます。明示的なブロックは、別のブロックの途中にreturnステートメントを追加するためにも使用されることがあります（§3.3.4参照）。

3.3.2 – チャンク

Luaのコンパイル単位は、チャンクと呼ばれます。構文的には、チャンクは単なるブロックです。

	chunk ::= block

Luaは、チャンクを可変数の引数を持つ匿名関数の本体として扱います（§3.4.11参照）。そのため、チャンクはローカル変数を定義したり、引数を受け取ったり、値を返したりできます。さらに、そのような匿名関数は、_ENVと呼ばれる外部ローカル変数のスコープ内でコンパイルされます（§2.2参照）。結果の関数は、その変数を使用しなくても、常に_ENVを唯一の外部変数として持ちます。

チャンクは、ファイルまたはホストプログラム内の文字列に格納できます。チャンクを実行するために、Luaはまずチャンクをロードし、チャンクのコードを仮想マシンの命令にプリコンパイルします。次に、Luaは仮想マシンのインタープリターを使用して、コンパイルされたコードを実行します。

チャンクはバイナリ形式にプリコンパイルすることもできます。詳細については、プログラムluacおよび関数string.dumpを参照してください。ソース形式とコンパイル形式のプログラムは交換可能です。Luaはファイルタイプを自動的に検出して、それに応じて動作します（loadを参照）。

3.3.3 – 代入

Luaでは、複数の代入が可能です。したがって、代入の構文では、左側に変数のリスト、右側に式のリストを定義します。両方のリストの要素は、カンマで区切られます。

	stat ::= varlist ‘=’ explist
	varlist ::= var {‘,’ var}
	explist ::= exp {‘,’ exp}

式については、§3.4で説明します。

代入の前に、値のリストは変数のリストの長さに調整されます（§3.4.12参照）。

複数の代入の中で変数が代入と読み取りの両方を行っている場合、Luaはすべての読み取りが代入前の変数の値を取得するようにします。したがって、次のコード

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

は、a[i]のiが（4が代入される前に）3と評価されるため、a[3]を20に設定し、a[4]には影響を与えません。同様に、次の行

     x, y = y, x

は、xとyの値を交換し、

     x, y, z = y, z, x

は、x、y、およびzの値を循環的に並べ替えます。

この保証は、代入ステートメントの構文内のアクセスのみを対象としていることに注意してください。代入中に呼び出された関数またはメタメソッドが変数の値を変更した場合、Luaはそのアクセスの順序について保証しません。

グローバル名x = valへの代入は、代入_ENV.x = valと同等です（§2.2参照）。

テーブルフィールドとグローバル変数（実際にはテーブルフィールドでもあります）への代入の意味は、メタテーブルを介して変更できます（§2.4参照）。

3.3.4 – 制御構造

制御構造if、while、およびrepeatは、通常の意味と使い慣れた構文を持ちます。

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

Luaには、2つの形式のforステートメントもあります（§3.3.5参照）。

制御構造の条件式は、任意の値 を返すことができます。falseとnilの両方がfalseとして評価されます。nilとfalse以外のすべての値はtrueとして評価されます。特に、数値の0と空の文字列もtrueとして評価されます。

repeat-untilループでは、内部ブロックはuntilキーワードでは終了せず、条件の後でのみ終了します。したがって、条件はループブロック内で宣言されたローカル変数を参照できます。

gotoステートメントは、プログラム制御をラベルに転送します。構文上の理由から、Luaのラベルもステートメントと見なされます。

	stat ::= goto Name
	stat ::= label
	label ::= ‘::’ Name ‘::’

ラベルは、ネストされた関数内を除き、定義されているブロック全体で可視になります。gotoは、ローカル変数のスコープに入らない限り、任意の可視ラベルにジャンプできます。ラベルは、同じ名前のラベルが可視になっている場合は、たとえこの他のラベルが外側のブロックで宣言されている場合でも、宣言しないでください。

breakステートメントは、while、repeat、またはforループの実行を終了し、ループ後の次のステートメントにスキップします。

	stat ::= break

breakは、最も内側の囲みループを終了します。

returnステートメントは、関数またはチャンク（匿名関数として扱われます）から値を返すために使用されます。関数は複数の値を返すことができるため、returnステートメントの構文は次のようになります。

	stat ::= return [explist] [‘;’]

returnステートメントは、ブロックの最後のステートメントとしてのみ記述できます。ブロックの途中でreturnする必要がある場合は、慣用句do return endのように、明示的な内部ブロックを使用できます。これは、returnが（内部）ブロックの最後のステートメントになるためです。

3.3.5 – Forステートメント

forステートメントには、数値形式とジェネリック形式の2つの形式があります。

数値forループ

数値forループは、制御変数が算術進行をたどる間、コードブロックを繰り返します。次の構文があります。

	stat ::= for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end

指定された識別子（Name）は、ループ本体（ブロック）のローカルである新しい制御変数を定義します。

ループは、3つの制御式を1回評価することから始まります。それらの値は、それぞれ初期値、制限値、ステップと呼ばれます。ステップがない場合、デフォルトは1です。

初期値とステップの両方が整数の場合、ループは整数で実行されます。制限値は整数でない場合があることに注意してください。それ以外の場合、3つの値は浮動小数点数に変換され、ループは浮動小数点数で実行されます。この場合、浮動小数点数の精度に注意してください。

その初期化の後、ループ本体は、ステップで指定された共通差で、初期値から始まる算術進行をたどる制御変数の値で繰り返されます。負のステップは減少シーケンスを作成します。ゼロに等しいステップはエラーを発生させます。ループは、値が制限値以下（負のステップの場合は制限値以上）である間、続行します。初期値がすでに制限値よりも大きい（または、ステップが負の場合は小さい）場合、本体は実行されません。

整数ループの場合、制御変数がラップアラウンドすることはありません。代わりに、オーバーフローの場合にループが終了します。

ループ中に制御変数の値を変更しないでください。ループ後にその値が必要な場合は、ループを終了する前に別の変数に割り当ててください。

ジェネリックforループ

ジェネリックforステートメントは、イテレーターと呼ばれる関数を対象として動作します。反復ごとに、イテレーター関数が新しい値を生成するために呼び出され、この新しい値がnilになると停止します。ジェネリックforループには、次の構文があります。

	stat ::= for namelist in explist do block end
	namelist ::= Name {‘,’ Name}

次のようなforステートメント

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

は、次のように機能します。

名前var_iは、ループ本体のローカルなループ変数を宣言します。これらの変数の最初の変数が制御変数です。

ループは、explistを評価して、4つの値を生成することから始まります。イテレーター関数、状態、制御変数の初期値、および終了値です。

次に、各反復で、Luaはイテレーター関数を2つの引数（状態と制御変数）とともに呼び出します。この呼び出しの結果は、複数の代入の規則に従ってループ変数に割り当てられます（§3.3.3参照）。制御変数がnilになると、ループが終了します。それ以外の場合、本体が実行され、ループは次の反復に進みます。

終了値は、ループが終了したときにリソースを解放するために使用できる、クローズされる変数（§3.3.8参照）のように動作します。それ以外の場合は、ループを妨げません。

ループ中に制御変数の値を変更しないでください。

3.3.6 – ステートメントとしての関数呼び出し

副作用の可能性を許可するために、関数呼び出しをステートメントとして実行できます。

	stat ::= functioncall

この場合、返されたすべての値は破棄されます。関数呼び出しについては、§3.4.10で説明します。

3.3.7 – ローカル宣言

ローカル変数は、ブロック内の任意の場所で宣言できます。宣言には初期化を含めることができます。

	stat ::= local attnamelist [‘=’ explist]
	attnamelist ::=  Name attrib {‘,’ Name attrib}

存在する場合、初期代入は複数代入と同じセマンティクスを持ちます（§3.3.3参照）。それ以外の場合、すべての変数はnilで初期化されます。

各変数名の後に属性（山かっこで囲まれた名前）を付けることができます。

	attrib ::= [‘<’ Name ‘>’]

可能な属性は2つあります。constは、定数変数、つまり初期化後に代入できない変数を宣言します。closeは、クローズされる変数を宣言します（§3.3.8参照）。変数のリストには、最大で1つのクローズされる変数を含めることができます。

チャンクもブロックであるため（§3.3.2参照）、ローカル変数を明示的なブロックの外部のチャンクで宣言できます。

ローカル変数の可視性規則については、§3.5で説明します。

3.3.8 – クローズされる変数

クローズされる変数は、定数ローカル変数のように動作しますが、変数がスコープ外になったときに、通常ブロックの終了、break/goto/returnによるブロックの終了、またはエラーによる終了を含め、その値がクローズされる点が異なります。

ここで、値をクローズするとは、その__closeメタメソッドを呼び出すことを意味します。メタメソッドを呼び出すとき、値自体が最初の引数として渡され、終了を引き起こしたエラーオブジェクト（存在する場合）が2番目の引数として渡されます。エラーがない場合は、2番目の引数はnilです。

クローズされる変数に割り当てられる値は、__closeメタメソッドを持つか、false値である必要があります。（nilとfalseは、クローズされる値として無視されます。）

同じイベントで複数のクローズされる変数がスコープ外になった場合、それらは宣言された逆の順序でクローズされます。

クロージングメソッドの実行中にエラーが発生した場合、そのエラーは、変数が定義された通常のコードでのエラーと同様に処理されます。エラーが発生した後も、他の保留中のクロージングメソッドは引き続き呼び出されます。

コルーチンが yield し、再開されない場合、一部の変数はスコープから外れない可能性があり、そのためクローズされることはありません。（これらの変数は、コルーチン内で作成され、コルーチンが yield した時点でスコープ内にあるものです。）同様に、コルーチンがエラーで終了した場合、スタックを巻き戻さないため、変数をクローズしません。どちらの場合も、ファイナライザーを使用するか、coroutine.closeを呼び出して変数をクローズできます。ただし、コルーチンがcoroutine.wrapを介して作成された場合、対応する関数はエラーが発生した場合にコルーチンをクローズします。

3.4 – 式

Lua の基本的な式は次のとおりです。

	exp ::= prefixexp
	exp ::= nil | false | true
	exp ::= Numeral
	exp ::= LiteralString
	exp ::= functiondef
	exp ::= tableconstructor
	exp ::= ‘...’
	exp ::= exp binop exp
	exp ::= unop exp
	prefixexp ::= var | functioncall | ‘(’ exp ‘)’

数値とリテラル文字列については§3.1で、変数については§3.2で、関数定義については§3.4.11で、関数呼び出しについては§3.4.10で、テーブルコンストラクターについては§3.4.9で説明されています。3つのドット('...')で示される可変長引数式は、可変長引数関数の内部でのみ直接使用できます。これについては§3.4.11で説明されています。

二項演算子には、算術演算子（§3.4.1を参照）、ビット演算子（§3.4.2を参照）、関係演算子（§3.4.4を参照）、論理演算子（§3.4.5を参照）、および連結演算子（§3.4.6を参照）が含まれます。単項演算子には、単項マイナス（§3.4.1を参照）、単項ビット単位 NOT（§3.4.2を参照）、単項論理 not（§3.4.5を参照）、および単項長さ演算子（§3.4.7を参照）が含まれます。

3.4.1 – 算術演算子

Lua は次の算術演算子をサポートしています。

• +: 加算
• -: 減算
• *: 乗算
• /: 浮動小数点除算
• //: 床関数除算
• %: 剰余
• ^: べき乗
• -: 単項マイナス

べき乗と浮動小数点除算を除いて、算術演算子は次のように動作します。両方のオペランドが整数の場合、演算は整数に対して実行され、結果は整数になります。それ以外の場合、両方のオペランドが数値の場合、それらは浮動小数点数に変換され、浮動小数点演算のマシンルール（通常は IEEE 754 標準）に従って演算が実行され、結果は浮動小数点数になります。（文字列ライブラリは算術演算で文字列を数値に強制変換します。詳細については§3.4.3を参照してください。）

べき乗と浮動小数点除算（/）は、常にオペランドを浮動小数点数に変換し、結果は常に浮動小数点数になります。べき乗は ISO C 関数 pow を使用するため、整数以外の指数にも対応できます。

床関数除算（//）は、商を負の無限大方向に丸める除算であり、オペランドの除算の床を返します。

剰余は、商を負の無限大方向（床関数除算）に丸める除算の余りとして定義されます。

整数演算でオーバーフローが発生した場合、すべての演算はラップアラウンドします。

3.4.2 – ビット演算子

Lua は次のビット演算子をサポートしています。

• &: ビット単位 AND
• |: ビット単位 OR
• ~: ビット単位排他的 OR
• >>: 右シフト
• <<: 左シフト
• ~: 単項ビット単位 NOT

すべてのビット単位演算は、オペランドを整数に変換し（§3.4.3を参照）、それらの整数のすべてのビットで演算を行い、整数を返します。

右シフトと左シフトの両方で、空いているビットはゼロで埋められます。負の変位は反対方向にシフトします。整数のビット数以上の絶対値を持つ変位は、ゼロになります（すべてのビットがシフトアウトされるため）。

3.4.3 – 強制型変換と変換

Lua は、実行時にいくつかの型と表現の間で自動変換を行います。ビット単位演算子は、常に浮動小数点オペランドを整数に変換します。べき乗と浮動小数点除算は、常に整数オペランドを浮動小数点数に変換します。混合数値（整数と浮動小数点数）に適用される他のすべての算術演算は、整数オペランドを浮動小数点数に変換します。C API は、必要に応じて整数を浮動小数点数に、浮動小数点数を整数に変換します。さらに、文字列連結は、文字列に加えて数値を引数として受け入れます。

整数から浮動小数点数への変換では、整数値が浮動小数点数として正確に表現できる場合、それが結果となります。それ以外の場合、変換は、最も近い大きい値または最も近い小さい表現可能な値を取得します。この種の変換は決して失敗しません。

浮動小数点数から整数への変換では、浮動小数点数が整数として正確に表現できるかどうか（つまり、浮動小数点数が整数値を持ち、整数の表現範囲内にあるかどうか）をチェックします。そうである場合、その表現が結果になります。それ以外の場合、変換は失敗します。

Lua のいくつかの場所では、必要に応じて文字列を数値に強制変換します。特に、文字列ライブラリは、すべての算術演算で文字列を数値に強制変換しようとするメタメソッドを設定します。変換が失敗した場合、ライブラリは他のオペランドのメタメソッド（存在する場合）を呼び出すか、エラーを発生させます。ビット単位演算子は、この強制変換を行わないことに注意してください。

文字列から数値への暗黙的な強制変換に依存しないことは常に良い習慣です。これらは常に適用されるわけではないためです。特に、"1"==1 は false であり、"1"<1 はエラーを発生させます（§3.4.4を参照）。これらの強制変換は主に互換性のために存在し、将来のバージョンの言語で削除される可能性があります。

文字列は、その構文と Lua レクサーのルールに従って、整数または浮動小数点数に変換されます。文字列には、先頭と末尾の空白と符号が含まれる場合もあります。文字列から数値へのすべての変換は、基数文字としてドットと現在のロケールマークの両方を受け入れます。（ただし、Lua レクサーはドットのみを受け入れます。）文字列が有効な数値でない場合、変換は失敗します。必要に応じて、この最初のステップの結果は、浮動小数点数と整数間の変換に関する前のルールに従って、特定の数値サブタイプに変換されます。

数値から文字列への変換では、指定されていない人間が読める形式を使用します。数値を特定の方法で文字列に変換するには、関数string.formatを使用してください。

3.4.4 – 関係演算子

Lua は次の関係演算子をサポートしています。

• ==: 等しい
• ~=: 等しくない
• <: より小さい
• >: より大きい
• <=: 以下
• >=: 以上

これらの演算子は常に false または true を返します。

等価性（==）は、最初にオペランドの型を比較します。型が異なる場合、結果は false です。それ以外の場合、オペランドの値が比較されます。文字列は、バイト内容が同じ場合に等しくなります。数値は、数学的に同じ値を表す場合に等しくなります。

テーブル、ユーザーデータ、およびスレッドは参照によって比較されます。2つのオブジェクトが等しいと見なされるのは、同じオブジェクトである場合のみです。新しいオブジェクト（テーブル、ユーザーデータ、またはスレッド）を作成するたびに、この新しいオブジェクトは、以前に存在したオブジェクトとは異なります。関数は常にそれ自身と等しくなります。検出可能な違い（動作の違い、定義の違い）を持つ関数は常に異なります。異なる時点で作成されたが、検出可能な違いがない関数は、等しいと分類される場合とされない場合があります（内部キャッシュの詳細によって異なります）。

__eqメタメソッドを使用すると、Lua がテーブルとユーザーデータを比較する方法を変更できます（§2.4を参照）。

等価性比較では、文字列を数値に、またはその逆に変換しません。したがって、"0"==0はfalseと評価され、t[0]とt["0"]はテーブル内の異なるエントリを表します。

演算子~=は、等価性（==）の否定です。

順序演算子は次のように動作します。両方の引数が数値の場合、それらはサブタイプに関係なく、数学的な値に従って比較されます。それ以外の場合、両方の引数が文字列である場合、それらの値は現在のロケールに従って比較されます。それ以外の場合、Lua は __lt または __le メタメソッドを呼び出そうとします（§2.4を参照）。比較 a > b は b < a に変換され、a >= b は b <= a に変換されます。

IEEE 754 標準に従い、特殊値 NaN は、それ自身を含め、どの値よりも小さい、等しい、または大きいとは見なされません。

3.4.5 – 論理演算子

Lua の論理演算子は、and、or、および not です。制御構造（§3.3.4を参照）と同様に、すべての論理演算子は、false と nil の両方を false とみなし、その他を true とみなします。

否定演算子 not は、常に false または true を返します。論理積演算子 and は、この値が false または nil である場合は最初の引数を返し、それ以外の場合は and は2番目の引数を返します。論理和演算子 or は、この値が nil および false と異なる場合は最初の引数を返し、それ以外の場合は or は2番目の引数を返します。and と or の両方で短絡評価が使用されます。つまり、2番目のオペランドは必要な場合にのみ評価されます。以下にいくつかの例を示します。

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

3.4.6 – 連結

Lua の文字列連結演算子は、2つのドット('..')で示されます。両方のオペランドが文字列または数値の場合、数値は指定されていない形式で文字列に変換されます（§3.4.3を参照）。それ以外の場合、__concatメタメソッドが呼び出されます（§2.4を参照）。

3.4.7 – 長さ演算子

長さ演算子は、単項プレフィックス演算子 # で示されます。

文字列の長さは、そのバイト数です。（つまり、各文字が1バイトの場合の文字列長の通常の意味です。）

テーブルに適用された長さ演算子は、そのテーブルの境界を返します。テーブル t の境界は、次の条件を満たす任意の非負の整数です。

     (border == 0 or t[border] ~= nil) and
     (t[border + 1] == nil or border == math.maxinteger)

言葉で言えば、境界とは、テーブル内に存在する正の整数インデックスであり、それに続いて存在しないインデックスが続く場合と、2つの制限ケースがあります。インデックス 1 が存在しない場合はゼロ、そのインデックスが存在する場合は整数の最大値です。正の整数ではないキーは、境界に干渉しないことに注意してください。

境界が1つしかないテーブルは、シーケンスと呼ばれます。たとえば、テーブル {10, 20, 30, 40, 50} は境界（5）が1つしかないため、シーケンスです。テーブル {10, 20, 30, nil, 50} には2つの境界（3と5）があるため、シーケンスではありません。（インデックス 4 の nil は穴と呼ばれます。）テーブル {nil, 20, 30, nil, nil, 60, nil} には3つの境界（0、3、および 6）があるため、これもシーケンスではありません。テーブル {} は境界 0 のシーケンスです。

t がシーケンスの場合、#t はその唯一の境界を返し、これはシーケンスの長さという直感的な概念に対応します。t がシーケンスでない場合、#t はその境界のいずれかを返す可能性があります。（どの境界が返されるかは、テーブルの内部表現の詳細に依存し、テーブルがどのようにデータが格納されたか、および数値ではないキーのメモリアドレスに依存します。）

テーブルの長さの計算は、最悪の場合でも O(log n) の時間が保証されています。ここで、n はテーブル内の最大の整数キーです。

プログラムは、__len メタメソッド（§2.4 を参照）を使用して、文字列以外の任意の値に対する長さ演算子の動作を変更できます。

3.4.8 – 優先順位

Lua における演算子の優先順位は、以下の表に従い、低いものから高いものの順に示します。

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

通常どおり、式での優先順位を変更するために括弧を使用できます。連結演算子 (..) とべき乗演算子 (^) は右結合です。その他のすべての二項演算子は左結合です。

3.4.9 – テーブルコンストラクタ

テーブルコンストラクタは、テーブルを作成する式です。コンストラクタが評価されるたびに、新しいテーブルが作成されます。コンストラクタは、空のテーブルを作成したり、テーブルを作成してそのフィールドの一部を初期化したりするために使用できます。コンストラクタの一般的な構文は次のとおりです。

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

[exp1] = exp2 の形式の各フィールドは、キーが exp1 で値が exp2 のエントリを新しいテーブルに追加します。name = exp の形式のフィールドは、["name"] = exp と同等です。exp の形式のフィールドは、[i] = exp と同等です。ここで、i は 1 から始まる連続した整数です。その他の形式のフィールドは、このカウントに影響しません。たとえば、

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

は、次のものと同等です。

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

コンストラクタ内での代入の順序は未定義です。（この順序は、キーが繰り返されている場合にのみ重要になります。）

リスト内の最後のフィールドが exp の形式であり、その式が複数結果の式である場合、この式によって返されるすべての値がリストに連続して入力されます（§3.4.12 を参照）。

フィールドリストには、機械生成されたコードの便宜のために、オプションの末尾の区切り記号を含めることができます。

3.4.10 – 関数呼び出し

Lua での関数呼び出しの構文は次のとおりです。

	functioncall ::= prefixexp args

関数呼び出しでは、最初に prefixexp と args が評価されます。prefixexp の値の型が function である場合、この関数は指定された引数で呼び出されます。それ以外の場合、prefixexp の __call メタメソッドが存在すればそれが呼び出されます。その最初の引数は prefixexp の値であり、その後に元の呼び出し引数が続きます（§2.4 を参照）。

次の形式

	functioncall ::= prefixexp ‘:’ Name args

は、メソッドをエミュレートするために使用できます。v:name(args) の呼び出しは、v.name(v,args) のシンタックスシュガーです。ただし、v は一度だけ評価されます。

引数の構文は次のとおりです。

	args ::= ‘(’ [explist] ‘)’
	args ::= tableconstructor
	args ::= LiteralString

すべての引数式は、呼び出し前に評価されます。f{fields} の形式の呼び出しは、f({fields}) のシンタックスシュガーです。つまり、引数リストは単一の新しいテーブルです。f'string' (または f"string" または f[[string]]) の形式の呼び出しは、f('string') のシンタックスシュガーです。つまり、引数リストは単一のリテラル文字列です。

閉じられる変数のスコープ内にない return functioncall の形式の呼び出しは、末尾呼び出しと呼ばれます。Lua は、適切な末尾呼び出し（または適切な末尾再帰）を実装しています。末尾呼び出しでは、呼び出される関数は呼び出し元の関数のスタックエントリを再利用します。したがって、プログラムが実行できるネストされた末尾呼び出しの数に制限はありません。ただし、末尾呼び出しは、呼び出し元の関数に関するデバッグ情報を消去します。末尾呼び出しは、return が引数として単一の関数呼び出しを持ち、閉じられる変数のスコープ外にある特定の構文でのみ発生することに注意してください。この構文により、呼び出し元の関数は、介入アクションなしに、呼び出された関数の戻り値を正確に返します。したがって、次の例はどれも末尾呼び出しではありません。

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

3.4.11 – 関数定義

関数定義の構文は次のとおりです。

	functiondef ::= function funcbody
	funcbody ::= ‘(’ [parlist] ‘)’ block end

次のシンタックスシュガーは、関数定義を簡略化します。

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

文

     function f () body end

は、次のように変換されます。

     f = function () body end

文

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

は、次のように変換されます。

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

文

     local function f () body end

は、次のように変換されます。

     local f; f = function () body end

ではなく、

     local f = function () body end

（これは、関数の本体に f への参照が含まれている場合にのみ違いが生じます。）

関数定義は、型が function の実行可能な式です。Lua がチャンクをプリコンパイルするとき、その関数本体はすべてプリコンパイルされますが、まだ作成されていません。その後、Lua が関数定義を実行するたびに、関数はインスタンス化（またはクローズ）されます。この関数インスタンス、またはクロージャは、式の最終的な値です。

パラメータは、引数値で初期化されるローカル変数として機能します。

	parlist ::= namelist [‘,’ ‘...’] | ‘...’

Lua 関数が呼び出されると、関数が可変長引数関数でない限り、引数リストをパラメータリストの長さに調整します（§3.4.12 を参照）。可変長引数関数は、パラメータリストの最後に3つのドット（...）で示されます。可変長引数関数は、引数リストを調整しません。代わりに、すべての追加引数を収集し、3つのドットとしても記述される可変長引数式を介して関数に提供します。この式の値は、複数結果を持つ関数と同様に、すべての実際の追加引数のリストです（§3.4.12 を参照）。

例として、次の定義を検討してください。

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

次に、引数からパラメータと可変長引数式への次のマッピングがあります。

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

結果は、return ステートメント（§3.3.4 を参照）を使用して返されます。制御が return ステートメントに遭遇せずに関数の終わりに到達した場合、関数は結果なしで返されます。

関数が返すことができる値の数には、システムに依存する制限があります。この制限は、1000 より大きいことが保証されています。

コロン構文は、関数に暗黙的な追加のパラメータ self を追加することで、メソッドをエミュレートするために使用されます。したがって、文

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

は、次のシンタックスシュガーです。

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

3.4.12 – 式のリスト、複数の結果、および調整

関数呼び出しと可変長引数式の両方が、複数の値を返す可能性があります。これらの式は、複数結果の式と呼ばれます。

複数結果の式が式のリストの最後の要素として使用される場合、式からのすべての結果が式のリストによって生成された値のリストに追加されます。式のリストを予期する場所に単一の式がある場合、その（シングルトン）リストの最後の式になることに注意してください。

これらは、Lua が式のリストを予期する場所です。

• return ステートメント。たとえば、return e1, e2, e3 （§3.3.4 を参照）。
• テーブルコンストラクタ。たとえば、{e1, e2, e3} （§3.4.9 を参照）。
• 関数呼び出しの引数。たとえば、foo(e1, e2, e3) （§3.4.10 を参照）。
• 複数代入。たとえば、a , b, c = e1, e2, e3 （§3.3.3 を参照）。
• ローカル宣言。たとえば、local a , b, c = e1, e2, e3 （§3.3.7 を参照）。
• 汎用 for ループでの初期値。たとえば、for k in e1, e2, e3 do ... end （§3.3.5 を参照）。

最後の4つのケースでは、式のリストからの値のリストを特定の長さに調整する必要があります。つまり、可変長引数関数ではない関数への呼び出しのパラメータ数（§3.4.11 を参照）、複数代入またはローカル宣言の変数の数、および汎用 for ループの場合は正確に4つの値です。調整は、次の規則に従います。必要な値よりも多くの値がある場合、余分な値は破棄されます。必要な値よりも少ない値がある場合、リストは nil で拡張されます。式のリストが複数結果の式で終わる場合、調整の前に、その式からのすべての結果が値のリストに入力されます。

複数結果の式が、最後の要素ではない式のリストで使用されている場合、または構文が単一の式を予期する場所で使用されている場合、Lua はその式の結果リストを1つの要素に調整します。特定の場合として、構文は括弧で囲まれた式の中に単一の式があることを予期します。したがって、複数結果の式の周囲に括弧を追加すると、正確に1つの結果が生成されます。

構文が単一の式を予期する場所で可変長引数式を使用する必要はほとんどありません。（通常、可変長引数部分の前に通常のパラメータを追加して、そのパラメータを使用する方が簡単です。）そのような必要がある場合は、可変長引数式を単一の変数に割り当てて、その変数を代わりに使用することをお勧めします。

複数結果の式の使用例を次に示します。すべての場合において、構成が「n番目の結果」を必要とし、そのような結果がない場合は、nil が使用されます。

     print(x, f())      -- prints x and all results from f().
     print(x, (f()))    -- prints x and the first result from f().
     print(f(), x)      -- prints the first result from f() and x.
     print(1 + f())     -- prints 1 added to the first result from f().
     local x = ...      -- x gets the first vararg argument.
     x,y = ...          -- x gets the first vararg argument,
                        -- y gets the second vararg argument.
     x,y,z = w, f()     -- x gets w, y gets the first result from f(),
                        -- z gets the second result from f().
     x,y,z = f()        -- x gets the first result from f(),
                        -- y gets the second result from f(),
                        -- z gets the third result from f().
     x,y,z = f(), g()   -- x gets the first result from f(),
                        -- y gets the first result from g(),
                        -- z gets the second result from g().
     x,y,z = (f())      -- x gets the first result from f(), y and z get nil.
     return f()         -- returns all results from f().
     return x, ...      -- returns x and all received vararg arguments.
     return x,y,f()     -- returns x, y, and all results from f().
     {f()}              -- creates a list with all results from f().
     {...}              -- creates a list with all vararg arguments.
     {f(), 5}           -- creates a list with the first result from f() and 5.

3.5 – 可視性ルール

Lua は、レキシカルスコープの言語です。ローカル変数のスコープは、宣言の後の最初のステートメントで始まり、宣言を含む最も内側のブロックの最後の非voidステートメントまで続きます。（Voidステートメントは、ラベルと空のステートメントです。）次の例を検討してください。

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

local x = x のような宣言では、宣言されている新しい x はまだスコープ内ではないため、2番目の 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個のインスタンス）を作成します。これらの各クロージャは異なる y 変数を使用しますが、すべて同じ x を共有します。

4 – アプリケーションプログラミングインターフェイス

このセクションでは、Lua の C API、つまり、Lua と通信するためにホストプログラムで使用できる C 関数のセットについて説明します。すべての API 関数および関連する型と定数は、ヘッダーファイル lua.h で宣言されています。

「関数」という用語を使用する場合でも、API の任意の機能は、代わりにマクロとして提供される場合があります。特に明記されていない限り、そのようなすべてのマクロは、引数を正確に一度だけ使用します（常に Lua ステートである最初の引数を除く）。したがって、隠れた副作用は生成されません。

ほとんどの C ライブラリと同様に、Lua API 関数は、引数の有効性または一貫性をチェックしません。ただし、マクロ LUA_USE_APICHECK を定義して Lua をコンパイルすることにより、この動作を変更できます。

Lua ライブラリは完全にリエントラントです。つまり、グローバル変数はありません。必要なすべての情報を、Lua ステートと呼ばれる動的な構造に保持します。

各 Lua ステートには、独立した協調的な実行ラインに対応する1つ以上のスレッドがあります。型 lua_State は（その名前にもかかわらず）スレッドを参照します。（間接的に、スレッドを介して、スレッドに関連付けられている Lua ステートも参照します。）

スレッドへのポインタは、ライブラリ内のすべての関数への最初の引数として渡す必要があります。ただし、lua_newstate は例外です。これは、Lua ステートを最初から作成し、新しいステートのメインスレッドへのポインタを返します。

4.1 – スタック

Lua は、値を C との間で受け渡すために、仮想スタックを使用します。このスタック内の各要素は、Lua 値（nil、数値、文字列など）を表します。API 内の関数は、受け取る Lua ステートパラメータを介してこのスタックにアクセスできます。

LuaがCを呼び出すたびに、呼び出された関数は新しいスタックを取得します。このスタックは、以前のスタックや、まだアクティブなC関数のスタックとは独立しています。このスタックには、最初にC関数への引数が含まれており、C関数は一時的なLua値を保存し、呼び出し元に返される結果をプッシュする必要があります（lua_CFunctionを参照）。

便宜上、APIのほとんどのクエリ操作は厳密なスタック規律に従いません。代わりに、インデックスを使用してスタック内の任意の要素を参照できます。正のインデックスは絶対スタック位置を表し、スタックの底を1として始まります。負のインデックスは、スタックの最上部を基準としたオフセットを表します。より具体的には、スタックにn個の要素がある場合、インデックス1は最初の要素（つまり、最初にスタックにプッシュされた要素）を表し、インデックスnは最後の要素を表します。インデックス-1も最後の要素（つまり、最上部の要素）を表し、インデックス-nは最初の要素を表します。

4.1.1 – スタックサイズ

Lua APIを操作するときは、一貫性を確保する責任があります。特に、スタックオーバーフローを制御する責任があります。API関数を呼び出すときは、スタックに結果を格納するのに十分な空き容量があることを確認する必要があります。

上記ルールには1つの例外があります。結果の数が固定されていないLua関数を呼び出す場合（lua_callを参照）、Luaはスタックにすべての結果を格納するのに十分なスペースがあることを保証します。ただし、追加のスペースは保証しません。したがって、このような呼び出しの後にスタックに何かをプッシュする前に、lua_checkstackを使用する必要があります。

LuaがCを呼び出すたびに、スタックに少なくともLUA_MINSTACK個の追加要素のためのスペースがあることを保証します。つまり、最大でLUA_MINSTACK個の値を安全にプッシュできます。LUA_MINSTACKは20として定義されているため、コードが要素をスタックにプッシュするループがない限り、通常はスタック領域を気にする必要はありません。必要に応じて、関数lua_checkstackを使用して、スタックに新しい要素をプッシュするための十分なスペースがあることを確認できます。

4.1.2 – 有効なインデックスと許容可能なインデックス

スタックインデックスを受け取るAPIの関数は、有効なインデックスまたは許容可能なインデックスでのみ機能します。

有効なインデックスとは、変更可能なLua値を格納する位置を参照するインデックスです。これは、1からスタックの最上部（1 ≤ abs(index) ≤ top）までのスタックインデックスと、Cコードからアクセスできるがスタックにはないいくつかの位置を表す擬似インデックスで構成されます。擬似インデックスは、レジストリ（§4.3を参照）とC関数のアップバリュー（§4.2を参照）にアクセスするために使用されます。

特定の変更可能な位置を必要とせず、値のみを必要とする関数（クエリ関数など）は、許容可能なインデックスで呼び出すことができます。許容可能なインデックスは、有効なインデックスのいずれかですが、スタック用に割り当てられた領域内のスタックの最上部より後の任意の正のインデックス、つまりスタックサイズまでのインデックスにすることもできます。（0は許容可能なインデックスではないことに注意してください。）現在のC関数の実際のアップバリュー数よりも大きいアップバリュー（§4.2を参照）へのインデックスも許容されます（ただし、無効です）。特に記載がない限り、APIの関数は許容可能なインデックスで動作します。

許容可能なインデックスは、スタックをクエリするときにスタックの最上部に対する追加のテストを回避するのに役立ちます。たとえば、C関数は、3番目の引数があるかどうかを確認する必要なく、つまり3が有効なインデックスであるかどうかを確認する必要なく、3番目の引数をクエリできます。

許容可能なインデックスで呼び出すことができる関数の場合、無効なインデックスは、仮想型LUA_TNONEの値を含むかのように扱われ、これはnil値のように動作します。

4.1.3 – 文字列へのポインタ

APIのいくつかの関数は、スタック内のLua文字列へのポインタ（const char*）を返します。（lua_pushfstring、lua_pushlstring、lua_pushstring、lua_tolstringを参照。また、補助ライブラリのluaL_checklstring、luaL_checkstring、luaL_tolstringも参照）。

一般に、Luaのガベージコレクションは内部メモリを解放または移動し、内部文字列へのポインタを無効にする可能性があります。これらのポインタを安全に使用できるように、APIは、スタックインデックスの文字列へのポインタは、そのインデックスの文字列値がスタックから削除されない限り有効であることを保証します。（ただし、別のインデックスに移動することはできます。）インデックスが（アップバリューを参照する）擬似インデックスである場合、ポインタは、対応する呼び出しがアクティブであり、対応するアップバリューが変更されない限り有効です。

デバッグインターフェースの一部の関数も、lua_getlocal、lua_getupvalue、lua_setlocal、lua_setupvalueなど、文字列へのポインタを返します。これらの関数では、呼び出し元の関数がアクティブであり、指定されたクロージャ（指定されている場合）がスタック内にある限り、ポインタが有効であることが保証されます。

これらの保証を除いて、ガベージコレクタは内部文字列へのポインタを自由に無効にすることができます。

4.2 – Cクロージャ

C関数が作成されるとき、いくつかの値をそれに関連付けて、Cクロージャを作成できます（lua_pushcclosureを参照）。これらの値はアップバリューと呼ばれ、呼び出されるたびに関数からアクセスできます。

C関数が呼び出されるたびに、そのアップバリューは特定の擬似インデックスに配置されます。これらの擬似インデックスは、マクロlua_upvalueindexによって生成されます。関数に関連付けられた最初のアップバリューは、インデックスlua_upvalueindex(1)にあり、以下同様です。lua_upvalueindex(n)へのアクセスは、nが現在の関数のアップバリューの数よりも大きい場合（ただし、クロージャ内のアップバリューの最大数に1を加えた256以下の場合）は、許容可能だが無効なインデックスを生成します。

Cクロージャは、対応するアップバリューの値を変更することもできます。

4.3 – レジストリ

Luaは、任意のCコードがLua値を格納するために使用できる、事前定義されたテーブルであるレジストリを提供します。レジストリテーブルは、常に擬似インデックスLUA_REGISTRYINDEXでアクセスできます。任意のCライブラリは、このテーブルにデータを格納できますが、他のライブラリが使用するキーとは異なるキーを選択して、競合を回避する必要があります。通常、キーとしてライブラリ名を含む文字列、またはコード内のCオブジェクトのアドレスを持つライトuserdata、またはコードによって作成された任意のLuaオブジェクトを使用する必要があります。変数名と同様に、アンダースコアで始まり、大文字が続く文字列キーはLua用に予約されています。

レジストリの整数キーは、参照メカニズム（luaL_refを参照）およびいくつかの事前定義された値によって使用されます。したがって、レジストリの整数キーを他の目的で使用しないでください。

新しいLua状態を作成すると、そのレジストリにはいくつかの事前定義された値が付属します。これらの事前定義された値には、lua.hの定数として定義された整数キーでインデックスが付けられています。次の定数が定義されています

• LUA_RIDX_MAINTHREAD: このインデックスでは、レジストリは状態のメインスレッドを持ちます。（メインスレッドは、状態とともに作成されたものです。）
• LUA_RIDX_GLOBALS: このインデックスでは、レジストリはグローバル環境を持ちます。

4.4 – Cでのエラー処理

内部的に、LuaはCのlongjmp機能を使用してエラーを処理します。（Luaは、C++としてコンパイルした場合、例外を使用します。詳細については、ソースコードでLUAI_THROWを検索してください。）Luaは、メモリ割り当てエラーや型エラーなどのエラーに直面すると、エラーを発生させます。つまり、long jumpを実行します。保護された環境はsetjmpを使用してリカバリポイントを設定します。エラーは、最も最近のアクティブなリカバリポイントにジャンプします。

C関数内では、lua_errorを呼び出すことで、エラーを明示的に発生させることができます。

APIのほとんどの関数は、たとえばメモリ割り当てエラーが原因でエラーを発生させる可能性があります。各関数のドキュメントには、エラーを発生させる可能性があるかどうかが示されています。

保護された環境の外でエラーが発生した場合、Luaはパニック関数（lua_atpanicを参照）を呼び出し、次にabortを呼び出して、ホストアプリケーションを終了します。パニック関数は、（たとえば、Luaの外の独自のリカバリポイントにlong jumpを実行して）戻らないことで、この終了を回避できます。

パニック関数は、名前が示すように、最後の手段のメカニズムです。プログラムはそれを避ける必要があります。原則として、C関数がLua状態を持つLuaによって呼び出される場合、すでに保護されているため、そのLua状態に対して必要なことを実行できます。ただし、Cコードが他のLua状態（たとえば、関数へのLua状態引数、レジストリに格納されているLua状態、またはlua_newthreadの結果）を操作する場合、エラーを発生させないAPI呼び出しでのみそれらを使用する必要があります。

パニック関数は、メッセージハンドラのように実行されます（§2.3を参照）。特に、エラーオブジェクトはスタックの最上部にあります。ただし、スタック領域については保証はありません。スタックに何かをプッシュするには、パニック関数は最初に利用可能なスペースを確認する必要があります（§4.1.1を参照）。

4.4.1 – ステータスコード

APIでエラーを報告するいくつかの関数は、さまざまな種類のエラーまたはその他の状態を示すために、次のステータスコードを使用します

• LUA_OK (0): エラーなし。
• LUA_ERRRUN: ランタイムエラー。
• LUA_ERRMEM: メモリ割り当てエラー。このようなエラーの場合、Luaはメッセージハンドラを呼び出しません。
• LUA_ERRERR: メッセージハンドラの実行中にエラーが発生しました。
• LUA_ERRSYNTAX: 事前コンパイル中の構文エラー。
• LUA_YIELD: スレッド（コルーチン）が中断されました。
• LUA_ERRFILE: ファイル関連のエラー。たとえば、ファイルを開いたり読み取ったりできません。

これらの定数は、ヘッダーファイルlua.hで定義されています。

4.5 – Cでの中断の処理

内部的には、LuaはコルーチンをyieldするためにCのlongjmp機能を使用します。そのため、C関数fooがAPI関数を呼び出し、このAPI関数が（直接的またはyieldする別の関数を呼び出すことによって間接的に）yieldする場合、longjmpによってCスタックからフレームが削除されるため、Luaはもはやfooに戻ることができません。

この種の問題を回避するために、LuaはAPI呼び出しをまたいでyieldしようとするたびにエラーを発生させます。ただし、lua_yieldk、lua_callk、およびlua_pcallkの3つの関数は例外です。これらの関数はすべて、yield後に実行を継続するための継続関数（kという名前のパラメータとして）を受け取ります。

継続を説明するために、いくつかの用語を設定する必要があります。Luaから呼び出されたC関数を、元の関数と呼びます。この元の関数は、C APIのこれら3つの関数のいずれかを呼び出し、これを呼び出し先関数と呼びます。そして、呼び出し先関数が現在のスレッドをyieldします。これは、呼び出し先関数がlua_yieldkである場合、または呼び出し先関数がlua_callkまたはlua_pcallkのいずれかであり、それらによって呼び出された関数がyieldする場合に発生します。

呼び出し先関数の実行中に実行中のスレッドがyieldすると仮定します。スレッドが再開した後、最終的に呼び出し先関数の実行が完了します。ただし、Cスタック内のフレームはyieldによって破棄されているため、呼び出し先関数は元の関数に戻ることができません。代わりに、Luaは継続関数を呼び出します。この継続関数は、呼び出し先関数の引数として渡されたものです。名前が示すように、継続関数は元の関数のタスクを継続する必要があります。

例として、次の関数を考えてみましょう。

     int original_function (lua_State *L) {
       ...     /* code 1 */
       status = lua_pcall(L, n, m, h);  /* calls Lua */
       ...     /* code 2 */
     }

ここで、lua_pcallによって実行されるLuaコードがyieldできるようにしたいとします。まず、ここで示すように関数を書き直すことができます。

     int k (lua_State *L, int status, lua_KContext ctx) {
       ...  /* code 2 */
     }
     
     int original_function (lua_State *L) {
       ...     /* code 1 */
       return k(L, lua_pcall(L, n, m, h), ctx);
     }

上記のコードでは、新しい関数kは継続関数（lua_KFunction型）であり、lua_pcallを呼び出した後に元の関数が行っていたすべての作業を行う必要があります。次に、lua_pcallによって実行されているLuaコードが何らかの方法（エラーまたはyield）で中断された場合にkを呼び出す必要があることをLuaに通知する必要があります。そのため、lua_pcallをlua_pcallkに置き換えて、コードをここで示すように書き換えます。

     int original_function (lua_State *L) {
       ...     /* code 1 */
       return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
     }

継続への外部からの明示的な呼び出しに注意してください。Luaは、エラーが発生した場合やyield後に再開する場合など、必要な場合にのみ継続を呼び出します。呼び出された関数がyieldせずに正常に返った場合、lua_pcallk（およびlua_callk）も正常に返ります。（もちろん、その場合に継続を呼び出す代わりに、元の関数内で同等の作業を直接行うことができます。）

Luaの状態に加えて、継続関数には他の2つのパラメータがあります。それは呼び出しの最終ステータスと、最初にlua_pcallkに渡されたコンテキスト値（ctx）です。Luaはこのコンテキスト値を使用しません。元の関数から継続関数にこの値を渡すだけです。lua_pcallkの場合、ステータスはlua_pcallkによって返される値と同じですが、yield後に実行されている場合は（LUA_OKではなく）LUA_YIELDになります。lua_yieldkおよびlua_callkの場合、Luaが継続を呼び出すときのステータスは常にLUA_YIELDです。（これらの2つの関数では、エラーが発生した場合に継続を呼び出すことはありません。エラーを処理しないためです。）同様に、lua_callkを使用する場合は、ステータスとしてLUA_OKを指定して継続関数を呼び出す必要があります。（lua_yieldkの場合、通常lua_yieldkは返さないため、継続関数を直接呼び出すことにあまり意味はありません。）

Luaは、継続関数を元の関数であるかのように扱います。継続関数は、元の関数と同じLuaスタックを、呼び出し先関数が返された場合と同じ状態で受け取ります。（たとえば、lua_callkの後、関数とその引数はスタックから削除され、呼び出しの結果に置き換えられます。）また、同じアップ値も持ちます。それが返すものはすべて、元の関数の戻り値としてLuaによって処理されます。

4.6 – 関数と型

ここでは、C APIのすべての関数と型をアルファベット順にリストします。各関数には、次のようなインジケータがあります: [-o, +p, x]

最初のフィールドoは、関数がスタックからポップする要素の数です。2番目のフィールドpは、関数がスタックにプッシュする要素の数です。（すべての関数は常に、引数をポップした後で結果をプッシュします。）x|y形式のフィールドは、関数が状況に応じてxまたはy要素をプッシュ（またはポップ）できることを意味します。疑問符'?'は、引数だけを見て関数がポップ/プッシュする要素の数を知ることができないことを意味します。（たとえば、スタックの内容に依存する場合があります。）3番目のフィールドxは、関数がエラーを発生させる可能性があるかどうかを示します。 '-'は関数がエラーを発生させないことを意味します。 'm'は関数がメモリ不足エラーのみを発生させる可能性があることを意味します。 'v'は、テキストで説明されているエラーを関数が発生させる可能性があることを意味します。 'e'は関数が直接またはメタメソッドを通じて任意のLuaコードを実行できるため、任意のエラーが発生する可能性があることを意味します。

lua_absindex

[-0, +0, –]

int lua_absindex (lua_State *L, int idx);

許容可能なインデックスidxを、同等の絶対インデックス（つまり、スタックサイズに依存しないインデックス）に変換します。

lua_Alloc

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

Luaの状態によって使用されるメモリアロケーション関数の型。アロケータ関数は、reallocに似た機能を提供する必要がありますが、まったく同じではありません。その引数は、lua_newstateに渡される不透明なポインタであるud、割り当て/再割り当て/解放されるブロックへのポインタであるptr、ブロックの元のサイズまたは割り当てられているものに関するコードであるosize、およびブロックの新しいサイズであるnsizeです。

ptrがNULLでない場合、osizeはptrによって指されるブロックのサイズ、つまり、割り当てまたは再割り当て時に指定されたサイズです。

ptrがNULLの場合、osizeはLuaが割り当てているオブジェクトの種類をエンコードします。osizeは、Luaがその型の新しいオブジェクトを作成している場合（およびその場合にのみ）、LUA_TSTRING、LUA_TTABLE、LUA_TFUNCTION、LUA_TUSERDATA、またはLUA_TTHREADのいずれかになります。osizeが他の値である場合、Luaは他の何かに対してメモリを割り当てています。

Luaは、アロケータ関数から次の動作を想定します。

nsizeがゼロの場合、アロケータはfreeのように動作し、NULLを返す必要があります。

nsizeがゼロでない場合、アロケータはreallocのように動作する必要があります。特に、アロケータはリクエストを完了できない場合にのみNULLを返します。

アロケータ関数の簡単な実装を次に示します。これは、補助ライブラリでluaL_newstateによって使用されます。

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

ISO Cでは、free(NULL)には効果がなく、realloc(NULL,size)はmalloc(size)と同等であることが保証されていることに注意してください。

lua_arith

[-(2|1), +1, e]

void lua_arith (lua_State *L, int op);

スタックの先頭にある2つの値（または否定の場合には1つ）に対して算術演算またはビット演算を実行します。スタックの先頭の値が2番目のオペランドになります。これらの値をポップし、演算の結果をプッシュします。この関数は、対応するLua演算子のセマンティクスに従います（つまり、メタメソッドを呼び出す場合があります）。

opの値は、次の定数のいずれかである必要があります。

• LUA_OPADD: 加算（+）を実行
• LUA_OPSUB: 減算（-）を実行
• LUA_OPMUL: 乗算（*）を実行
• LUA_OPDIV: 浮動小数点除算（/）を実行
• LUA_OPIDIV: 床除算（//）を実行
• LUA_OPMOD: モジュロ（%）を実行
• LUA_OPPOW: 指数演算（^）を実行
• LUA_OPUNM: 数学的な否定（単項-）を実行
• LUA_OPBNOT: ビット単位のNOT（~）を実行
• LUA_OPBAND: ビット単位のAND（&）を実行
• LUA_OPBOR: ビット単位のOR（|）を実行
• LUA_OPBXOR: ビット単位の排他的OR（~）を実行
• LUA_OPSHL: 左シフト（<<）を実行
• LUA_OPSHR: 右シフト（>>）を実行

lua_atpanic

[-0, +0, –]

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);

新しいパニック関数を設定し、古い関数を返します（§4.4を参照）。

lua_call

[-(nargs+1), +nresults, e]

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

関数を呼び出します。通常のLua呼び出しと同様に、lua_callは__callメタメソッドを尊重します。したがって、ここで「関数」という言葉は、呼び出し可能な値を意味します。

呼び出しを行うには、次のプロトコルを使用する必要があります。最初に、呼び出す関数をスタックにプッシュします。次に、呼び出しの引数を直接の順序でプッシュします。つまり、最初の引数が最初にプッシュされます。最後にlua_callを呼び出します。nargsはスタックにプッシュした引数の数です。関数が戻ると、すべての引数と関数値がポップされ、呼び出し結果がスタックにプッシュされます。結果の数はnresultsに調整されます。ただし、nresultsがLUA_MULTRETの場合を除きます。この場合、関数からのすべての結果がプッシュされます。Luaは、返された値がスタックスペースに収まるようにしますが、スタック内の追加のスペースを保証しません。関数の結果は直接の順序で（最初の結果が最初にプッシュされる）スタックにプッシュされるため、呼び出し後、最後の結果がスタックの先頭になります。

関数の呼び出しおよび実行中のエラーはすべて、上位に（longjmpを使用して）伝播されます。

次の例は、ホストプログラムがこのLuaコードと同等の処理をどのように実行できるかを示しています。

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

以下はCでの記述です。

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

上記のコードはバランスが取れていることに注意してください。最後に、スタックは元の構成に戻ります。これは、優れたプログラミングの習慣と見なされます。

lua_callk

[-(nargs + 1), +nresults, e]

void lua_callk (lua_State *L,
                int nargs,
                int nresults,
                lua_KContext ctx,
                lua_KFunction k);

この関数は、lua_callとまったく同じように動作しますが、呼び出された関数がyieldできるようにします（§4.5を参照）。

lua_CFunction

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

C 関数の型。

Luaと正しく通信するために、C関数は次のプロトコルに従う必要があります。このプロトコルは、パラメータと結果がどのように渡されるかを定義します。C関数は、Luaから引数をスタックに直接順に受け取ります（最初の引数が最初にプッシュされます）。したがって、関数が開始すると、lua_gettop(L)は関数が受け取った引数の数を返します。最初の引数（存在する場合）はインデックス1にあり、最後の引数はインデックスlua_gettop(L)にあります。Luaに値を返すには、C関数はそれらをスタックに直接順にプッシュし（最初の結果が最初にプッシュされます）、Cで結果の数を返します。結果の下のスタックにある他の値は、Luaによって適切に破棄されます。Lua関数と同様に、Luaによって呼び出されるC関数も多くの結果を返すことができます。

例として、次の関数は可変数の数値引数を受け取り、それらの平均と合計を返します。

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

lua_checkstack

[-0, +0, –]

int lua_checkstack (lua_State *L, int n);

スタックに少なくともn個の追加要素のためのスペースがあること、つまり、最大n個の値を安全にプッシュできることを保証します。スタックが固定の最大サイズ（通常、数千個以上の要素）を超える場合、または追加のスペース用のメモリを割り当てることができないために、要求を満たすことができない場合は、falseを返します。この関数はスタックを縮小することはありません。スタックにすでに余分な要素のためのスペースがある場合、変更されずに残ります。

lua_close

[-0, +0, –]

void lua_close (lua_State *L);

メインスレッドでアクティブなすべてのクローズ対象変数を閉じ、指定されたLua状態のすべてのオブジェクトを解放し（対応するガベージコレクションメタメソッド（存在する場合）を呼び出し）、この状態によって使用されるすべての動的メモリを解放します。

一部のプラットフォームでは、ホストプログラムが終了するとすべてのリソースが自然に解放されるため、この関数を呼び出す必要がない場合があります。一方、デーモンやWebサーバーなど、複数の状態を作成する長時間実行されるプログラムは、不要になった状態をできるだけ早く閉じる必要があるでしょう。

lua_closeslot

[-0, +0, e]

void lua_closeslot (lua_State *L, int index);

指定されたインデックスにあるクローズ対象のスロットを閉じ、その値をnilに設定します。インデックスは、まだアクティブ（つまり、まだ閉じられていない）である、以前にクローズ対象としてマークされた最後のインデックス（lua_tocloseを参照）である必要があります。

この関数を介して呼び出された場合、__closeメタメソッドはyieldできません。

（この関数はリリース5.4.3で導入されました。）

lua_closethread

[-0, +?, –]

int lua_closethread (lua_State *L, lua_State *from);

スレッドをリセットし、そのコールスタックをクリーンアップし、保留中のすべてのクローズ対象変数を閉じます。ステータスコードを返します。スレッドにエラーがない場合はLUA_OK（スレッドを停止させた元のエラー、またはクローズメソッドのエラー）、それ以外の場合はエラー状態です。エラーの場合、スタックのトップにエラーオブジェクトを残します。

パラメータfromは、Lをリセットしているコルーチンを表します。そのようなコルーチンがない場合、このパラメータはNULLにすることができます。

（この関数はリリース5.4.6で導入されました。）

lua_compare

[-0, +0, e]

int lua_compare (lua_State *L, int index1, int index2, int op);

2つのLua値を比較します。インデックスindex1の値が、対応するLua演算子のセマンティクスに従って（つまり、メタメソッドを呼び出す可能性がある）、インデックスindex2の値と比較した場合にopを満たす場合は1を返します。それ以外の場合は0を返します。また、いずれかのインデックスが無効な場合も0を返します。

opの値は、次の定数のいずれかである必要があります。

• LUA_OPEQ: 等価性（==）を比較します
• LUA_OPLT: より小さい（<）を比較します
• LUA_OPLE: 以下（<=）を比較します

lua_concat

[-n, +1, e]

void lua_concat (lua_State *L, int n);

スタックのトップにあるn個の値を連結し、それらをポップし、結果をトップに残します。nが1の場合、結果はスタック上の単一の値です（つまり、関数は何もしません）。nが0の場合、結果は空の文字列です。連結はLuaの通常のセマンティクスに従って実行されます（§3.4.6を参照）。

lua_copy

[-0, +0, –]

void lua_copy (lua_State *L, int fromidx, int toidx);

インデックスfromidxにある要素を有効なインデックスtoidxにコピーし、その位置の値を置き換えます。他の位置の値は影響を受けません。

lua_createtable

[-0, +1, m]

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

新しい空のテーブルを作成し、スタックにプッシュします。パラメータnarrは、テーブルがシーケンスとして持つ要素数のヒントです。パラメータnrecは、テーブルが持つ他の要素数のヒントです。Luaは、これらのヒントを使用して、新しいテーブルのメモリを事前に割り当てることができます。この事前割り当ては、テーブルにいくつの要素があるかを事前に知っている場合にパフォーマンスを向上させるのに役立つ場合があります。それ以外の場合は、関数lua_newtableを使用できます。

lua_dump

[-0, +0, –]

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

関数をバイナリチャンクとしてダンプします。スタックのトップにあるLua関数を受け取り、再度ロードした場合、ダンプされたものと同等の関数になるバイナリチャンクを生成します。チャンクの一部を生成するときに、lua_dumpは、指定されたdataを使用してそれらを書き込むために関数writer（lua_Writerを参照）を呼び出します。

stripがtrueの場合、バイナリ表現には、スペースを節約するために関数のすべてのデバッグ情報が含まれない場合があります。

返される値は、ライターへの最後の呼び出しによって返されるエラーコードです。0はエラーがないことを意味します。

この関数はスタックからLua関数をポップしません。

lua_error

[-1, +0, v]

int lua_error (lua_State *L);

スタックのトップにある値をエラーオブジェクトとして使用して、Luaエラーを発生させます。この関数はロングジャンプを実行するため、決して戻りません（luaL_errorを参照）。

lua_gc

[-0, +0, –]

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

ガベージコレクタを制御します。

この関数は、パラメータwhatの値に応じて、いくつかのタスクを実行します。追加の引数を必要とするオプションの場合、オプションの後にそれらがリストされます。

• LUA_GCCOLLECT: 完全なガベージコレクションサイクルを実行します。
• LUA_GCSTOP: ガベージコレクタを停止します。
• LUA_GCRESTART: ガベージコレクタを再起動します。
• LUA_GCCOUNT: Luaで使用されている現在のメモリ量（Kバイト単位）を返します。
• LUA_GCCOUNTB: Luaで使用されている現在のメモリ量（バイト単位）を1024で割った余りを返します。
• LUA_GCSTEP (int stepsize): stepsize Kバイトの割り当てに対応する、ガベージコレクションの増分ステップを実行します。
• LUA_GCISRUNNING: コレクターが実行中かどうか（つまり、停止していない）を示すブール値を返します。
• LUA_GCINC (int pause, int stepmul, stepsize): 指定されたパラメータを使用して、コレクターを増分モードに変更します（§2.5.1を参照）。以前のモード（LUA_GCGENまたはLUA_GCINC）を返します。
• LUA_GCGEN (int minormul, int majormul): 指定されたパラメータを使用して、コレクターを世代モードに変更します（§2.5.2を参照）。以前のモード（LUA_GCGENまたはLUA_GCINC）を返します。

これらのオプションの詳細については、collectgarbageを参照してください。

この関数はファイナライザーによって呼び出されるべきではありません。

lua_getallocf

[-0, +0, –]

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

指定された状態のメモリ割り当て関数を返します。udがNULLでない場合、Luaはメモリ割り当て関数が設定されたときに与えられた不透明なポインタを*udに格納します。

lua_getfield

[-0, +1, e]

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

スタックに値t[k]をプッシュします。ここで、tは指定されたインデックスにある値です。Luaと同様に、この関数は「index」イベントのメタメソッドをトリガーする場合があります（§2.4を参照）。

プッシュされた値の型を返します。

lua_getextraspace

[-0, +0, –]

void *lua_getextraspace (lua_State *L);

指定されたLua状態に関連付けられた生のメモリ領域へのポインタを返します。アプリケーションはこの領域を任意の目的で使用できます。Luaはそれを使用しません。

各新しいスレッドには、メインスレッドの領域のコピーで初期化されたこの領域があります。

デフォルトでは、この領域はvoidへのポインタのサイズですが、この領域の異なるサイズでLuaを再コンパイルできます。（luaconf.hのLUA_EXTRASPACEを参照）。

lua_getglobal

[-0, +1, e]

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

グローバルnameの値をスタックにプッシュします。その値の型を返します。

lua_geti

[-0, +1, e]

int lua_geti (lua_State *L, int index, lua_Integer i);

スタックに値t[i]をプッシュします。ここで、tは指定されたインデックスにある値です。Luaと同様に、この関数は「index」イベントのメタメソッドをトリガーする場合があります（§2.4を参照）。

プッシュされた値の型を返します。

lua_getmetatable

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

int lua_getmetatable (lua_State *L, int index);

指定されたインデックスの値にメタテーブルがある場合、関数はそのメタテーブルをスタックにプッシュし、1を返します。それ以外の場合、関数は0を返し、スタックには何もプッシュしません。

lua_gettable

[-1, +1, e]

int lua_gettable (lua_State *L, int index);

スタックに値t[k]をプッシュします。ここで、tは指定されたインデックスにある値であり、kはスタックのトップにある値です。

この関数は、スタックからキーをポップし、その場所に結果の値をプッシュします。Luaと同様に、この関数は「index」イベントのメタメソッドをトリガーする場合があります（§2.4を参照）。

プッシュされた値の型を返します。

lua_gettop

[-0, +0, –]

int lua_gettop (lua_State *L);

スタックのトップ要素のインデックスを返します。インデックスは1から始まるため、この結果はスタック内の要素数と同じです。特に、0は空のスタックを意味します。

lua_getiuservalue

[-0, +1, –]

int lua_getiuservalue (lua_State *L, int index, int n);

スタックに、指定されたインデックスにあるフルユーザーデータに関連付けられたn番目のユーザー値をプッシュし、プッシュされた値の型を返します。

ユーザーデータにその値がない場合、nilをプッシュし、LUA_TNONEを返します。

lua_insert

[-1, +1, –]

void lua_insert (lua_State *L, int index);

トップ要素を指定された有効なインデックスに移動し、このインデックスの上にある要素を上にシフトしてスペースを開きます。擬似インデックスは実際のスタック位置ではないため、この関数を擬似インデックスで呼び出すことはできません。

lua_Integer

typedef ... lua_Integer;

Luaの整数の型。

デフォルトでは、この型はlong long（通常は64ビットの2の補数整数）ですが、longまたはint（通常は32ビットの2の補数整数）に変更できます。（luaconf.hのLUA_INT_TYPEを参照）。

Luaは、この型に収まる最小値と最大値を使用して、定数LUA_MININTEGERとLUA_MAXINTEGERも定義します。

lua_isboolean

[-0, +0, –]

int lua_isboolean (lua_State *L, int index);

指定されたインデックスの値がブール値の場合は1を返し、それ以外の場合は0を返します。

lua_iscfunction

[-0, +0, –]

int lua_iscfunction (lua_State *L, int index);

指定されたインデックスの値がC関数の場合は1を返し、それ以外の場合は0を返します。

lua_isfunction

[-0, +0, –]

int lua_isfunction (lua_State *L, int index);

指定されたインデックスの値が関数（CまたはLua）の場合は1を返し、それ以外の場合は0を返します。

lua_isinteger

[-0, +0, –]

int lua_isinteger (lua_State *L, int index);

指定されたインデックスの値が整数（つまり、値が数値であり、整数として表現されている）であれば 1 を返し、そうでなければ 0 を返します。

lua_islightuserdata

[-0, +0, –]

int lua_islightuserdata (lua_State *L, int index);

指定されたインデックスの値がライトユーザーデータであれば 1 を返し、そうでなければ 0 を返します。

lua_isnil

[-0, +0, –]

int lua_isnil (lua_State *L, int index);

指定されたインデックスの値が nil であれば 1 を返し、そうでなければ 0 を返します。

lua_isnone

[-0, +0, –]

int lua_isnone (lua_State *L, int index);

指定されたインデックスが無効であれば 1 を返し、そうでなければ 0 を返します。

lua_isnoneornil

[-0, +0, –]

int lua_isnoneornil (lua_State *L, int index);

指定されたインデックスが無効であるか、そのインデックスの値が nil であれば 1 を返し、そうでなければ 0 を返します。

lua_isnumber

[-0, +0, –]

int lua_isnumber (lua_State *L, int index);

指定されたインデックスの値が数値または数値に変換可能な文字列であれば 1 を返し、そうでなければ 0 を返します。

lua_isstring

[-0, +0, –]

int lua_isstring (lua_State *L, int index);

指定されたインデックスの値が文字列または数値（常に文字列に変換可能）であれば 1 を返し、そうでなければ 0 を返します。

lua_istable

[-0, +0, –]

int lua_istable (lua_State *L, int index);

指定されたインデックスの値がテーブルであれば 1 を返し、そうでなければ 0 を返します。

lua_isthread

[-0, +0, –]

int lua_isthread (lua_State *L, int index);

指定されたインデックスの値がスレッドであれば 1 を返し、そうでなければ 0 を返します。

lua_isuserdata

[-0, +0, –]

int lua_isuserdata (lua_State *L, int index);

指定されたインデックスの値がユーザーデータ（フルまたはライト）であれば 1 を返し、そうでなければ 0 を返します。

lua_isyieldable

[-0, +0, –]

int lua_isyieldable (lua_State *L);

指定されたコルーチンが yield できる場合は 1 を返し、それ以外の場合は 0 を返します。

lua_KContext

typedef ... lua_KContext;

継続関数コンテキストの型。数値型でなければなりません。この型は、intptr_t が利用可能な場合は intptr_t として定義され、ポインタも格納できるようにします。それ以外の場合は、ptrdiff_t として定義されます。

lua_KFunction

typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);

継続関数の型（§4.5 を参照）。

lua_len

[-0, +1, e]

void lua_len (lua_State *L, int index);

指定されたインデックスの値の長さを返します。Lua の '#' 演算子（§3.4.7 を参照）と同等であり、「length」イベントのメタメソッドをトリガーする場合があります（§2.4 を参照）。結果はスタックにプッシュされます。

lua_load

[-0, +1, –]

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

Lua のチャンクを実行せずにロードします。エラーがない場合、lua_load はコンパイルされたチャンクを Lua 関数としてスタックの一番上にプッシュします。それ以外の場合は、エラーメッセージをプッシュします。

lua_load 関数は、チャンクを読み込むためにユーザーが提供する reader 関数を使用します（lua_Reader を参照）。data 引数は、reader 関数に渡される不透明な値です。

chunkname 引数は、エラーメッセージやデバッグ情報で使用されるチャンクの名前を指定します（§4.7 を参照）。

lua_load は、チャンクがテキスト形式かバイナリ形式かを自動的に検出し、それに応じてロードします（プログラム luac を参照）。文字列 mode は、関数 load と同様に動作しますが、NULL 値は文字列 "bt" と同等であるという追加があります。

lua_load は内部でスタックを使用するため、reader 関数は常に、戻る際にスタックを変更しないようにする必要があります。

lua_load は LUA_OK、LUA_ERRSYNTAX、または LUA_ERRMEM を返すことができます。この関数は、読み取り関数によって発生したエラーに対応する他の値を返す場合もあります（§4.4.1 を参照）。

結果の関数にアップバリューがある場合、その最初のアップバリューは、レジストリのインデックス LUA_RIDX_GLOBALS に格納されているグローバル環境の値に設定されます（§4.3 を参照）。メインチャンクをロードする場合、このアップバリューは _ENV 変数になります（§2.2 を参照）。他のアップバリューは nil で初期化されます。

lua_newstate

[-0, +0, –]

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

新しい独立した状態を作成し、そのメスレッドを返します。状態を作成できない場合（メモリ不足が原因）は NULL を返します。引数 f はアロケーター関数です。Lua は、この状態のすべてのメモリ割り当てをこの関数を介して行います（lua_Alloc を参照）。2 番目の引数 ud は、Lua がすべての呼び出しでアロケーターに渡す不透明なポインタです。

lua_newtable

[-0, +1, m]

void lua_newtable (lua_State *L);

新しい空のテーブルを作成し、それをスタックにプッシュします。これは lua_createtable(L, 0, 0) と同等です。

lua_newthread

[-0, +1, m]

lua_State *lua_newthread (lua_State *L);

新しいスレッドを作成し、スタックにプッシュし、この新しいスレッドを表す lua_State へのポインタを返します。この関数によって返される新しいスレッドは、元のスレッドとグローバル環境を共有しますが、独立した実行スタックを持ちます。

スレッドは、他の Lua オブジェクトと同様に、ガベージコレクションの対象となります。

lua_newuserdatauv

[-0, +1, m]

void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue);

この関数は、新しいフルユーザーデータをスタックに作成してプッシュします。このユーザーデータには、nuvalue 個の関連する Lua 値（ユーザー値 と呼ばれます）と、size バイトの関連する生のメモリブロックがあります。（ユーザー値は、関数 lua_setiuservalue および lua_getiuservalue で設定および読み取ることができます。）

この関数は、メモリブロックのアドレスを返します。Lua は、対応するユーザーデータが存続している限り、このアドレスが有効であることを保証します（§2.5 を参照）。さらに、ユーザーデータがファイナライズのためにマークされている場合（§2.5.3 を参照）、そのアドレスは少なくともファイナライザーの呼び出しまで有効です。

lua_next

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

int lua_next (lua_State *L, int index);

スタックからキーをポップし、指定されたインデックスのテーブルからキーと値のペア（指定されたキーの「次の」ペア）をプッシュします。テーブルに要素がなくなると、lua_next は 0 を返し、何もプッシュしません。

一般的なテーブルトラバーサルは次のようになります。

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

テーブルのトラバーサル中は、キーが実際に文字列であることがわかっている場合を除き、キーに対して直接 lua_tolstring を呼び出すことは避けてください。lua_tolstring は指定されたインデックスの値を変更する可能性があることに注意してください。これは、lua_next の次の呼び出しを混乱させます。

指定されたキーが nil でもない場合、テーブルに存在しない場合は、この関数がエラーを発生させる可能性があります。テーブルのトラバーサル中にテーブルを変更する場合の注意点については、関数 next を参照してください。

lua_Number

typedef ... lua_Number;

Lua の浮動小数点数の型。

デフォルトでは、この型は double ですが、単精度 float または long double に変更できます。（luaconf.h の LUA_FLOAT_TYPE を参照。）

lua_numbertointeger

int lua_numbertointeger (lua_Number n, lua_Integer *p);

Lua の浮動小数点数を Lua の整数に変換しようとします。浮動小数点数 n は整数値でなければなりません。その値が Lua の整数の範囲内にある場合は、整数に変換され、*p に代入されます。このマクロは、変換が成功したかどうかを示すブール値を返します。（この範囲テストは、このマクロがないと正しく行うのが難しい場合があることに注意してください。）

このマクロは、引数を複数回評価する場合があります。

lua_pcall

[-(nargs + 1), +(nresults|1), –]

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

関数（または呼び出し可能なオブジェクト）を保護モードで呼び出します。

nargs と nresults の両方とも、lua_call と同じ意味を持ちます。呼び出し中にエラーがない場合、lua_pcall は lua_call とまったく同じように動作します。ただし、エラーが発生した場合、lua_pcall はそれをキャッチし、単一の値をスタックにプッシュし（エラーオブジェクト）、エラーコードを返します。lua_call と同様に、lua_pcall は常にスタックから関数とその引数を削除します。

msgh が 0 の場合、スタックに返されるエラーオブジェクトは元のエラーオブジェクトとまったく同じです。それ以外の場合、msgh はメッセージハンドラーのスタックインデックスです。（このインデックスは疑似インデックスにすることはできません。）ランタイムエラーが発生した場合、このハンドラーはエラーオブジェクトとともに呼び出され、その戻り値は lua_pcall によってスタックに返されるオブジェクトになります。

通常、メッセージハンドラーは、スタックトレースバックなど、エラーオブジェクトに詳細なデバッグ情報を追加するために使用されます。このような情報は、lua_pcall の戻り後には収集できません。スタックが巻き戻されているためです。

lua_pcall 関数は、次のステータスコードのいずれかを返します。LUA_OK、LUA_ERRRUN、LUA_ERRMEM、または LUA_ERRERR。

lua_pcallk

[-(nargs + 1), +(nresults|1), –]

int lua_pcallk (lua_State *L,
                int nargs,
                int nresults,
                int msgh,
                lua_KContext ctx,
                lua_KFunction k);

この関数は、呼び出された関数が yield できることを除いて（§4.5 を参照）、lua_pcall とまったく同じように動作します。

lua_pop

[-n, +0, e]

void lua_pop (lua_State *L, int n);

スタックから n 個の要素をポップします。これは、lua_settop に対するマクロとして実装されています。

lua_pushboolean

[-0, +1, –]

void lua_pushboolean (lua_State *L, int b);

値 b を持つブール値をスタックにプッシュします。

lua_pushcclosure

[-n, +1, m]

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

新しい C クロージャをスタックにプッシュします。この関数は C 関数へのポインタを受け取り、対応する C 関数を呼び出す、呼び出し時に function 型の Lua 値をスタックにプッシュします。パラメーター n は、この関数が持つアップバリューの数を指定します（§4.2 を参照）。

Lua から呼び出し可能なすべての関数は、パラメーターを受け取り、結果を返すための正しいプロトコルに従う必要があります（lua_CFunction を参照）。

C 関数が作成されるとき、アップバリューと呼ばれるいくつかの値をそれに関連付けることができます。これらのアップバリューは、関数が呼び出されるたびにアクセスできます。この関連付けは C クロージャと呼ばれます（§4.2 を参照）。C クロージャを作成するには、最初にアップバリューの初期値をスタックにプッシュする必要があります。（複数のアップバリューがある場合、最初の値が最初にプッシュされます。）次に、lua_pushcclosure を呼び出して、C 関数をスタックに作成してプッシュします。引数 n は、関数に関連付けられる値の数を指定します。lua_pushcclosure は、これらの値もスタックからポップします。

n の最大値は 255 です。

n が 0 の場合、この関数はライト C 関数を作成します。これは C 関数へのポインタにすぎません。その場合、メモリエラーが発生することはありません。

lua_pushcfunction

[-0, +1, –]

void lua_pushcfunction (lua_State *L, lua_CFunction f);

C 関数をスタックにプッシュします。この関数は、アップバリューがない lua_pushcclosure と同等です。

lua_pushfstring

[-0, +1, v]

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

書式設定された文字列をスタックにプッシュし、この文字列へのポインタを返します（§4.1.3 を参照）。これは ISO C 関数 sprintf に似ていますが、2 つの重要な違いがあります。まず、結果のスペースを割り当てる必要はありません。結果は Lua 文字列であり、Lua がメモリ割り当て（およびガベージコレクションによる割り当て解除）を処理します。2 番目に、変換指定子はかなり制限されています。フラグ、幅、または精度はありません。変換指定子は '%%' (文字 '%' を挿入)、'%s' (ヌル終端文字列を挿入、サイズ制限なし)、'%f' (lua_Number を挿入)、'%I' (lua_Integer を挿入)、'%p' (ポインタを挿入)、'%d' (int を挿入)、'%c' (1 バイト文字として int を挿入)、および '%U' (UTF-8 バイトシーケンスとして long int を挿入) のみです。

この関数は、メモリオーバーフローまたは無効な変換指定子によるエラーを発生させる場合があります。

lua_pushglobaltable

[-0, +1, –]

void lua_pushglobaltable (lua_State *L);

グローバル環境をスタックにプッシュします。

lua_pushinteger

[-0, +1, –]

void lua_pushinteger (lua_State *L, lua_Integer n);

値 n を持つ整数をスタックにプッシュします。

lua_pushlightuserdata

[-0, +1, –]

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

ライトユーザーデータをスタックにプッシュします。

ユーザーデータは Lua で C 値を表します。ライトユーザーデータはポインタ（void*）を表します。これは値（数値のような）であり、作成されず、個別のメタテーブルを持たず、収集されません（作成されなかったため）。ライトユーザーデータは、同じ C アドレスを持つ「任意」のライトユーザーデータと等しくなります。

lua_pushliteral

[-0, +1, m]

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

このマクロは lua_pushstring と同等ですが、s がリテラル文字列の場合にのみ使用する必要があります。（Lua はこのケースを最適化する場合があります。）

lua_pushlstring

[-0, +1, m]

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

サイズ len の s が指す文字列をスタックにプッシュします。Lua は指定された文字列の内部コピーを作成または再利用するため、関数が戻った直後に s のメモリを解放または再利用できます。文字列には、埋め込みゼロを含む任意のバイナリデータを含めることができます。

文字列の内部コピーへのポインタを返します（§4.1.3 を参照）。

lua_pushnil

[-0, +1, –]

void lua_pushnil (lua_State *L);

スタックにnil値をプッシュします。

lua_pushnumber

[-0, +1, –]

void lua_pushnumber (lua_State *L, lua_Number n);

スタックに値がnであるfloat値をプッシュします。

lua_pushstring

[-0, +1, m]

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

sが指すゼロ終端文字列をスタックにプッシュします。Luaは与えられた文字列の内部コピーを作成または再利用するため、関数が戻った直後にsのメモリを解放または再利用できます。

文字列の内部コピーへのポインタを返します（§4.1.3 を参照）。

sがNULLの場合、nilをプッシュしてNULLを返します。

lua_pushthread

[-0, +1, –]

int lua_pushthread (lua_State *L);

Lで表されるスレッドをスタックにプッシュします。このスレッドがそのステートのメインスレッドである場合は1を返します。

lua_pushvalue

[-0, +1, –]

void lua_pushvalue (lua_State *L, int index);

与えられたインデックスにある要素のコピーをスタックにプッシュします。

lua_pushvfstring

[-0, +1, v]

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

lua_pushfstringと同等ですが、可変個数の引数の代わりにva_listを受け取ります。

lua_rawequal

[-0, +0, –]

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

インデックスindex1とindex2にある2つの値がプリミティブに等しい（つまり、__eqメタメソッドを呼び出さずに等しい）場合は1を返します。それ以外の場合は0を返します。いずれかのインデックスが無効な場合も0を返します。

lua_rawget

[-1, +1, –]

int lua_rawget (lua_State *L, int index);

lua_gettableに似ていますが、生のアクセス（つまり、メタメソッドなし）を行います。indexの値はテーブルでなければなりません。

lua_rawgeti

[-0, +1, –]

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

スタックに値t[n]をプッシュします。ここで、tは与えられたインデックスにあるテーブルです。アクセスは生であり、__indexメタ値を使用しません。

プッシュされた値の型を返します。

lua_rawgetp

[-0, +1, –]

int lua_rawgetp (lua_State *L, int index, const void *p);

スタックに値t[k]をプッシュします。ここで、tは与えられたインデックスにあるテーブルであり、kはライトユーザーデータとして表現されたポインタpです。アクセスは生であり、つまり__indexメタ値を使用しません。

プッシュされた値の型を返します。

lua_rawlen

[-0, +0, –]

lua_Unsigned lua_rawlen (lua_State *L, int index);

与えられたインデックスの値の生の「長さ」を返します。文字列の場合は文字列の長さ、テーブルの場合はメタメソッドなしの長さ演算子（'#'）の結果、ユーザーデータの場合はユーザーデータに割り当てられたメモリブロックのサイズです。その他の値の場合、この呼び出しは0を返します。

lua_rawset

[-2, +0, m]

void lua_rawset (lua_State *L, int index);

lua_settableに似ていますが、生の代入（つまり、メタメソッドなし）を行います。indexの値はテーブルでなければなりません。

lua_rawseti

[-1, +0, m]

void lua_rawseti (lua_State *L, int index, lua_Integer i);

t[i] = vと同等の処理を行います。ここで、tは与えられたインデックスにあるテーブルであり、vはスタックの一番上の値です。

この関数はスタックから値をポップします。代入は生であり、つまり__newindexメタ値を使用しません。

lua_rawsetp

[-1, +0, m]

void lua_rawsetp (lua_State *L, int index, const void *p);

t[p] = vと同等の処理を行います。ここで、tは与えられたインデックスにあるテーブル、pはライトユーザーデータとしてエンコードされ、vはスタックの一番上の値です。

この関数はスタックから値をポップします。代入は生であり、つまり__newindexメタ値を使用しません。

lua_Reader

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

lua_loadで使用されるリーダ関数。 lua_loadがチャンクの別の部分を必要とするたびに、リーダを呼び出し、そのdataパラメータを渡します。リーダは、チャンクの新しい部分を持つメモリブロックへのポインタを返し、sizeをブロックサイズに設定する必要があります。ブロックは、リーダ関数が再度呼び出されるまで存在する必要があります。チャンクの終わりを知らせるために、リーダはNULLを返すか、sizeをゼロに設定する必要があります。リーダ関数は、ゼロより大きい任意のサイズのピースを返すことができます。

lua_register

[-0, +0, e]

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

グローバル変数nameの新しい値としてC関数fを設定します。これはマクロとして定義されています

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

lua_remove

[-1, +0, –]

void lua_remove (lua_State *L, int index);

指定された有効なインデックスにある要素を削除し、このインデックスより上の要素を下に移動してギャップを埋めます。疑似インデックスは実際のスタック位置ではないため、この関数を疑似インデックスで呼び出すことはできません。

lua_replace

[-1, +0, –]

void lua_replace (lua_State *L, int index);

スタックの一番上の要素を与えられた有効なインデックスに移動し、他の要素をシフトすることなく（したがって、指定されたインデックスの値を置き換え）、一番上の要素をポップします。

lua_resetthread

[-0, +?, –]

int lua_resetthread (lua_State *L);

この関数は非推奨です。fromがNULLであるlua_closethreadと同等です。

lua_resume

[-?, +?, –]

int lua_resume (lua_State *L, lua_State *from, int nargs,
                          int *nresults);

与えられたスレッドLでコルーチンを開始および再開します。

コルーチンを開始するには、メイン関数と任意の引数をスレッドの空のスタックにプッシュします。次に、lua_resumeを呼び出し、nargsを引数の数とします。この呼び出しは、コルーチンが中断するか実行を終了したときに戻ります。戻ると、*nresultsが更新され、スタックの一番上にはlua_yieldに渡された値、または本体関数によって返された値である*nresults値が含まれています。コルーチンが中断した場合、lua_resumeはLUA_YIELDを返します。コルーチンがエラーなしで実行を終了した場合はLUA_OKを返し、エラーの場合はエラーコードを返します（§4.4.1を参照）。エラーの場合、エラーオブジェクトはスタックの一番上にあります。

コルーチンを再開するには、スタックから*nresultsのyieldされた値を削除し、yieldの結果として渡される値をプッシュしてから、lua_resumeを呼び出します。

パラメータfromはLを再開するコルーチンを表します。そのようなコルーチンがない場合、このパラメータはNULLにすることができます。

lua_rotate

[-0, +0, –]

void lua_rotate (lua_State *L, int idx, int n);

有効なインデックスidxとスタックの一番上の要素の間でスタック要素を回転させます。要素は、正のnの場合は一番上の方向にnの位置だけ、または負のnの場合は一番下の方向に-nの位置だけ回転します。nの絶対値は、回転されるスライスのサイズを超えてはなりません。疑似インデックスは実際のスタック位置ではないため、この関数を疑似インデックスで呼び出すことはできません。

lua_setallocf

[-0, +0, –]

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

与えられたステートのアロケータ関数を、ユーザーデータudを使用してfに変更します。

lua_setfield

[-1, +0, e]

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

t[k] = vと同等の処理を行います。ここで、tは与えられたインデックスの値であり、vはスタックの一番上の値です。

この関数はスタックから値をポップします。 Luaの場合と同様に、この関数は「newindex」イベントのメタメソッドをトリガーする可能性があります（§2.4を参照）。

lua_setglobal

[-1, +0, e]

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

スタックから値をポップし、グローバル変数nameの新しい値として設定します。

lua_seti

[-1, +0, e]

void lua_seti (lua_State *L, int index, lua_Integer n);

t[n] = vと同等の処理を行います。ここで、tは与えられたインデックスの値であり、vはスタックの一番上の値です。

この関数はスタックから値をポップします。 Luaの場合と同様に、この関数は「newindex」イベントのメタメソッドをトリガーする可能性があります（§2.4を参照）。

lua_setiuservalue

[-1, +0, –]

int lua_setiuservalue (lua_State *L, int index, int n);

スタックから値をポップし、与えられたインデックスにあるフルユーザーデータに関連付けられた新しいn番目のユーザー値として設定します。ユーザーデータにその値がない場合は0を返します。

lua_setmetatable

[-1, +0, –]

int lua_setmetatable (lua_State *L, int index);

スタックからテーブルまたはnilをポップし、その値を、指定されたインデックスの値の新しいメタテーブルとして設定します（nilはメタテーブルがないことを意味します）。

（歴史的な理由から、この関数はintを返しますが、現在は常に1です。）

lua_settable

[-2, +0, e]

void lua_settable (lua_State *L, int index);

t[k] = vと同等の処理を行います。ここで、tは与えられたインデックスの値、vはスタックの一番上の値、kは一番上の値のすぐ下の値です。

この関数は、キーと値の両方をスタックからポップします。 Luaの場合と同様に、この関数は「newindex」イベントのメタメソッドをトリガーする可能性があります（§2.4を参照）。

lua_settop

[-?, +?, e]

void lua_settop (lua_State *L, int index);

任意のインデックス、または0を受け入れ、スタックの一番上をこのインデックスに設定します。新しい一番上が古いものよりも大きい場合、新しい要素はnilで埋められます。indexが0の場合、すべてのスタック要素が削除されます。

この関数は、スタックから閉じられるとマークされたインデックスを削除するときに、任意のコードを実行できます。

lua_setwarnf

[-0, +0, –]

void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud);

Luaが警告を発行するために使用する警告関数を設定します（lua_WarnFunctionを参照）。udパラメータは、警告関数に渡される値udを設定します。

lua_State

typedef struct lua_State lua_State;

スレッド、および（スレッドを介して間接的に）Luaインタープリターの全体の状態を指す不透明な構造体。 Luaライブラリは完全に再入可能です。グローバル変数はありません。ステートに関するすべての情報は、この構造体を介してアクセスできます。

この構造体へのポインタは、Luaステートを最初から作成するlua_newstateを除く、ライブラリ内のすべての関数への最初の引数として渡す必要があります。

lua_status

[-0, +0, –]

int lua_status (lua_State *L);

スレッドLのステータスを返します。

ステータスは、通常のスレッドの場合はLUA_OK、スレッドがエラーでlua_resumeの実行を終了した場合はエラーコード、スレッドが中断されている場合はLUA_YIELDになります。

LUA_OKステータスのスレッドでのみ関数を呼び出すことができます。LUA_OK（新しいコルーチンを開始する）またはLUA_YIELD（コルーチンを再開する）ステータスのスレッドを再開できます。

lua_stringtonumber

[-0, +1, –]

size_t lua_stringtonumber (lua_State *L, const char *s);

ゼロ終端文字列sを数値に変換し、その数値をスタックにプッシュし、文字列の合計サイズ、つまりその長さ+1を返します。変換は、Luaの字句規則に従って、整数または浮動小数点数になる場合があります（§3.1を参照）。文字列には、先頭と末尾の空白と符号が含まれている場合があります。文字列が有効な数値でない場合は、0を返し、何もプッシュしません（結果はブール値として使用でき、変換が成功した場合はtrueになります）。

lua_toboolean

[-0, +0, –]

int lua_toboolean (lua_State *L, int index);

与えられたインデックスにあるLua値をCのブール値（0または1）に変換します。 Luaのすべてのテストと同様に、lua_tobooleanは、falseおよびnilとは異なるLua値に対してtrueを返し、それ以外の場合はfalseを返します。（実際のブール値のみを受け入れる場合は、lua_isbooleanを使用して値の型をテストします。）

lua_tocfunction

[-0, +0, –]

lua_CFunction lua_tocfunction (lua_State *L, int index);

与えられたインデックスの値C関数に変換します。その値はC関数である必要があります。それ以外の場合は、NULLを返します。

lua_toclose

[-0, +0, m]

void lua_toclose (lua_State *L, int index);

スタックの指定されたインデックスを、閉じられるスロットとしてマークします（§3.3.8を参照）。 Luaの閉じられる変数と同様に、スタックのそのスロットの値は、スコープ外になると閉じられます。ここで、C関数のコンテキストでは、スコープ外になるとは、実行中の関数がLuaに戻るか、エラーが発生するか、lua_settopまたはlua_popを使用してスロットがスタックから削除されるか、lua_closeslotが呼び出されることを意味します。閉じられるとマークされたスロットは、lua_closeslotによって事前に非アクティブ化されない限り、lua_settopまたはlua_pop以外のAPIの他の関数によってスタックから削除しないでください。

この関数は、アクティブな閉じられるスロットと同じか下にあるインデックスに対して呼び出さないでください。

エラーの場合も通常の戻りの場合も、__closeメタメソッドが実行されるまでに、Cスタックはすでに巻き戻されているため、呼び出し関数で宣言された自動C変数（例：バッファ）はスコープ外になることに注意してください。

lua_tointeger

[-0, +0, –]

lua_Integer lua_tointeger (lua_State *L, int index);

isnumがNULLに等しいlua_tointegerxと同等です。

lua_tointegerx

[-0, +0, –]

lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);

指定されたインデックスにある Lua の値を、符号付き整数型 lua_Integer に変換します。Lua の値は整数であるか、整数に変換可能な数値または文字列である必要があります（§3.4.3を参照）。それ以外の場合、lua_tointegerx は 0 を返します。

isnum が NULL でない場合、操作が成功したかどうかを示すブール値が、その参照先に代入されます。

lua_tolstring

[-0, +0, m]

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

指定されたインデックスにある Lua の値を C 文字列に変換します。len が NULL でない場合、*len に文字列の長さが設定されます。Lua の値は文字列または数値である必要があります。それ以外の場合、関数は NULL を返します。値が数値の場合、lua_tolstring はスタック内の実際の値も文字列に変更します。（この変更は、テーブルトラバース中に lua_tolstring がキーに適用されると、lua_next を混乱させます。）

lua_tolstring は Lua の状態内の文字列へのポインタを返します（§4.1.3を参照）。この文字列は常に最後の文字の後にゼロ ('\0') がありますが（C のように）、本体には他のゼロを含めることができます。

lua_tonumber

[-0, +0, –]

lua_Number lua_tonumber (lua_State *L, int index);

isnum が NULL である lua_tonumberx と同等です。

lua_tonumberx

[-0, +0, –]

lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);

指定されたインデックスにある Lua の値を C 型 lua_Number に変換します（lua_Numberを参照）。Lua の値は数値であるか、数値に変換可能な文字列である必要があります（§3.4.3を参照）。それ以外の場合、lua_tonumberx は 0 を返します。

isnum が NULL でない場合、操作が成功したかどうかを示すブール値が、その参照先に代入されます。

lua_topointer

[-0, +0, –]

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

指定されたインデックスにある値を汎用 C ポインタ (void*) に変換します。値は userdata、テーブル、スレッド、文字列、または関数である可能性があります。それ以外の場合、lua_topointer は NULL を返します。異なるオブジェクトは異なるポインタを提供します。ポインタを元の値に戻す方法はありません。

通常、この関数はハッシュとデバッグ情報にのみ使用されます。

lua_tostring

[-0, +0, m]

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

len が NULL である lua_tolstring と同等です。

lua_tothread

[-0, +0, –]

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

指定されたインデックスにある値を Lua スレッド (lua_State* として表現) に変換します。この値はスレッドである必要があります。それ以外の場合、関数は NULL を返します。

lua_touserdata

[-0, +0, –]

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

指定されたインデックスの値が完全な userdata の場合、そのメモリーブロックアドレスを返します。値が light userdata の場合、その値 (ポインタ) を返します。それ以外の場合は、NULL を返します。

lua_type

[-0, +0, –]

int lua_type (lua_State *L, int index);

指定された有効なインデックスにある値の型を返します。または、無効ではあるが許容可能なインデックスの場合は LUA_TNONE を返します。lua_type によって返される型は、lua.h で定義された次の定数によってコード化されます。 LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD, および LUA_TLIGHTUSERDATA。

lua_typename

[-0, +0, –]

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

lua_type によって返された値のいずれかである必要がある値 tp によってエンコードされた型の名前を返します。

lua_Unsigned

typedef ... lua_Unsigned;

lua_Integer の符号なしバージョン。

lua_upvalueindex

[-0, +0, –]

int lua_upvalueindex (int i);

実行中の関数の i 番目のアップバリューを表す疑似インデックスを返します（§4.2を参照）。i は [1,256] の範囲内である必要があります。

lua_version

[-0, +0, –]

lua_Number lua_version (lua_State *L);

このコアのバージョン番号を返します。

lua_WarnFunction

typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);

Lua によって警告を生成するために呼び出される警告関数の型です。最初のパラメータは、lua_setwarnf によって設定された不透明なポインタです。2番目のパラメータは警告メッセージです。3番目のパラメータは、メッセージを次の呼び出しのメッセージで継続する必要があるかどうかを示すブール値です。

警告の詳細については、warn を参照してください。

lua_warning

[-0, +0, –]

void lua_warning (lua_State *L, const char *msg, int tocont);

指定されたメッセージで警告を発行します。tocont が true の呼び出しでのメッセージは、この関数の別の呼び出しで継続する必要があります。

警告の詳細については、warn を参照してください。

lua_Writer

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

lua_dump によって使用されるライター関数の型です。lua_dump がチャンクの別の部分を生成するたびに、ライターを呼び出し、書き込まれるバッファ (p)、そのサイズ (sz)、および lua_dump に提供された ud パラメータを渡します。

ライターはエラーコードを返します。0 はエラーがないことを意味します。それ以外の値はエラーを意味し、lua_dump がライターを再度呼び出すのを停止します。

lua_xmove

[-?, +?, –]

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

同じ状態の異なるスレッド間で値を交換します。

この関数は、スタック from から n 個の値をポップし、スタック to にプッシュします。

lua_yield

[-?, +?, v]

int lua_yield (lua_State *L, int nresults);

この関数は lua_yieldk と同等ですが、継続がありません (§4.5 を参照)。したがって、スレッドが再開されると、lua_yield を呼び出す関数を呼び出した関数が続行されます。予期しない事態を避けるために、この関数は末尾呼び出しでのみ呼び出す必要があります。

lua_yieldk

[-?, +?, v]

int lua_yieldk (lua_State *L,
                int nresults,
                lua_KContext ctx,
                lua_KFunction k);

コルーチン（スレッド）を譲ります。

C 関数が lua_yieldk を呼び出すと、実行中のコルーチンはその実行を中断し、このコルーチンを開始した lua_resume の呼び出しが戻ります。パラメータ nresults は、lua_resume の結果として渡されるスタックからの値の数です。

コルーチンが再び再開されると、Lua は与えられた継続関数 k を呼び出して、譲った C 関数の実行を継続します (§4.5 を参照)。この継続関数は、前の関数と同じスタックを、n 個の結果を削除し、lua_resume に渡された引数に置き換えて受け取ります。さらに、継続関数は、lua_yieldk に渡された値 ctx を受け取ります。

通常、この関数は戻りません。コルーチンが最終的に再開すると、継続関数の実行を続行します。ただし、1つの特別なケースがあります。それは、この関数がラインまたはカウントフックの中から呼び出された場合です（§4.7 を参照）。その場合、lua_yieldk は継続なしで（おそらく lua_yield の形式で）および結果なしで呼び出す必要があり、フックは呼び出し後すぐに戻る必要があります。Lua は譲り、コルーチンが再び再開すると、フックをトリガーした (Lua) 関数の通常の実行を続行します。

継続関数を持たない保留中の C 呼び出しがあるスレッド（C 呼び出し境界と呼ばれる）から呼び出された場合、または再開内で実行されていないスレッド（通常はメインスレッド）から呼び出された場合、この関数はエラーを発生させる可能性があります。

4.7 – デバッグインターフェース

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) */
  size_t srclen;              /* (S) */
  int currentline;            /* (l) */
  int linedefined;            /* (S) */
  int lastlinedefined;        /* (S) */
  unsigned char nups;         /* (u) number of upvalues */
  unsigned char nparams;      /* (u) number of parameters */
  char isvararg;              /* (u) */
  char istailcall;            /* (t) */
  unsigned short ftransfer;   /* (r) index of first value transferred */
  unsigned short ntransfer;   /* (r) number of transferred values */
  char short_src[LUA_IDSIZE]; /* (S) */
  /* private part */
  other fields
} lua_Debug;

関数またはアクティベーションレコードに関するさまざまな情報を伝達するために使用される構造体。lua_getstack は、後で使用するために、この構造体のプライベート部分のみを埋めます。 lua_Debug の他のフィールドを有用な情報で埋めるには、適切なパラメータを使用して lua_getinfo を呼び出す必要があります。（具体的には、フィールドを取得するには、フィールドのコメント内の括弧で囲まれた文字を lua_getinfo のパラメータ what に追加する必要があります。）

lua_Debug のフィールドには次の意味があります

• source: 関数を作成したチャンクのソース。source が '@' で始まる場合、関数がファイル内で定義されたことを意味し、ファイル名は '@' の後に続きます。source が '=' で始まる場合、そのコンテンツの残りはユーザーに依存する方法でソースを記述します。それ以外の場合、関数は文字列で定義され、source はその文字列です。
• srclen: 文字列 source の長さ。
• short_src: エラーメッセージで使用される source の「印刷可能な」バージョン。
• linedefined: 関数の定義が始まる行番号。
• lastlinedefined: 関数の定義が終わる行番号。
• what: 関数が Lua 関数の場合は文字列 "Lua"、C 関数の場合は "C"、チャンクのメイン部分の場合は "main"。
• currentline: 与えられた関数が実行されている現在の行。行情報がない場合、currentline は -1 に設定されます。
• name: 与えられた関数の適切な名前。Lua の関数はファーストクラスの値であるため、固定された名前はありません。一部の関数は複数のグローバル変数の値になることがあり、他の関数はテーブルフィールドにのみ格納できます。 lua_getinfo 関数は、関数がどのように呼び出されたかを調べて適切な名前を見つけます。名前が見つからない場合、name は NULL に設定されます。
• namewhat: name フィールドを説明します。 namewhat の値は、関数がどのように呼び出されたかに応じて、"global"、"local"、"method"、"field"、"upvalue"、または ""（空文字列）のいずれかになります。（Lua は他のオプションが適用されないと思われる場合、空文字列を使用します。）
• istailcall: この関数の呼び出しが末尾呼び出しによって呼び出された場合は true。この場合、このレベルの呼び出し元はスタックにありません。
• nups: 関数のアップバリューの数。
• nparams: 関数のパラメータの数 (C 関数の場合は常に 0)。
• isvararg: 関数が可変長引数関数の場合 true (C 関数の場合は常に true)。
• ftransfer: 「転送」される最初の値、つまり呼び出しのパラメータまたは戻り値のスタック内のインデックス。(他の値は連続したインデックスにあります。) このインデックスを使用すると、lua_getlocal および lua_setlocal を介してこれらの値にアクセスして変更できます。このフィールドは、呼び出しフック中に最初のパラメータを示す場合、または返される最初の値を示す戻りフック中にのみ意味があります。（呼び出しフックの場合、この値は常に 1 です。）
• ntransfer: 転送される値の数 (前の項目を参照)。(Lua 関数の呼び出しの場合、この値は常に nparams と等しくなります。)

lua_gethook

[-0, +0, –]

lua_Hook lua_gethook (lua_State *L);

現在のフック関数を返します。

lua_gethookcount

[-0, +0, –]

int lua_gethookcount (lua_State *L);

現在のフックカウントを返します。

lua_gethookmask

[-0, +0, –]

int lua_gethookmask (lua_State *L);

現在のフックマスクを返します。

lua_getinfo

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

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

特定の関数または関数の呼び出しに関する情報を取得します。

関数の呼び出しに関する情報を取得するには、パラメータarは、以前のlua_getstackの呼び出しによって入力されたか、フックへの引数として渡された有効なアクティベーションレコードでなければなりません（lua_Hookを参照）。

関数に関する情報を取得するには、その関数をスタックにプッシュし、what文字列を文字'>'で開始します。（この場合、lua_getinfoはスタックのトップから関数をポップします。）たとえば、関数fが定義された行を知るには、次のコードを記述できます。

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

文字列whatの各文字は、構造体arのいくつかのフィールドを埋めるか、スタックにプッシュする値を選択します。（これらの文字は、構造体lua_Debugの宣言でも、各フィールドに続くコメントの括弧内にドキュメント化されています。）

• 'f'： 指定されたレベルで実行中の関数をスタックにプッシュします。
• 'l'： フィールドcurrentlineを埋めます。
• 'n'： フィールドnameおよびnamewhatを埋めます。
• 'r'： フィールドftransferおよびntransferを埋めます。
• 'S'： フィールドsource、short_src、linedefined、lastlinedefined、およびwhatを埋めます。
• 't'： フィールドistailcallを埋めます。
• 'u'： フィールドnups、nparams、およびisvarargを埋めます。
• 'L'： インデックスが、関連付けられたコードを持つ関数の行、つまりブレークポイントを設定できる行であるテーブルをスタックにプッシュします。（コードのない行には、空行とコメントが含まれます。）このオプションをオプション'f'とともに指定すると、そのテーブルは関数の後にプッシュされます。これは、メモリエラーが発生する可能性のある唯一のオプションです。

この関数は、whatに無効なオプションがあることを示すために0を返します。それでも、有効なオプションは正しく処理されます。

lua_getlocal

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

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

指定されたアクティベーションレコードまたは指定された関数のローカル変数または一時的な値に関する情報を取得します。

最初の場合、パラメータarは、以前のlua_getstackの呼び出しによって入力されたか、フックへの引数として渡された有効なアクティベーションレコードでなければなりません（lua_Hookを参照）。インデックスnは、検査するローカル変数を指定します。変数インデックスと名前の詳細については、debug.getlocalを参照してください。

lua_getlocalは、変数の値をスタックにプッシュし、その名前を返します。

2番目のケースでは、arはNULLでなければならず、検査する関数はスタックの最上位になければなりません。この場合、Lua関数のパラメータのみが表示され（アクティブな変数の情報がないため）、スタックには値がプッシュされません。

インデックスがアクティブなローカル変数の数よりも大きい場合は、NULLを返します（何もプッシュしません）。

lua_getstack

[-0, +0, –]

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

インタープリターのランタイムスタックに関する情報を取得します。

この関数は、指定されたレベルで実行中の関数の*アクティベーションレコード*の識別を使用してlua_Debug構造体の一部を埋めます。レベル0は現在実行中の関数であり、レベル*n+1*はレベル*n*を呼び出した関数です（スタックにカウントされない末尾呼び出しを除く）。スタックの深さよりも大きいレベルで呼び出されると、lua_getstackは0を返します。それ以外の場合は1を返します。

lua_getupvalue

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

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

インデックスfuncindexにあるクロージャのn番目のアップバリューに関する情報を取得します。アップバリューの値をスタックにプッシュし、その名前を返します。インデックスnがアップバリューの数よりも大きい場合は、NULLを返します（何もプッシュしません）。

アップバリューの詳細については、debug.getupvalueを参照してください。

lua_Hook

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

デバッグフック関数の型。

フックが呼び出されるたびに、そのar引数のフィールドeventには、フックをトリガーした特定のイベントが設定されます。Luaは、これらのイベントを次の定数で識別します：LUA_HOOKCALL、LUA_HOOKRET、LUA_HOOKTAILCALL、LUA_HOOKLINE、およびLUA_HOOKCOUNT。さらに、行イベントの場合、フィールドcurrentlineも設定されます。arの他のフィールドの値を取得するには、フックはlua_getinfoを呼び出す必要があります。

呼び出しイベントの場合、eventは通常の値であるLUA_HOOKCALL、または末尾呼び出しの場合はLUA_HOOKTAILCALLにすることができます。この場合、対応する戻りイベントはありません。

Luaがフックを実行している間、フックへの他の呼び出しは無効になります。したがって、フックがLuaを呼び出して関数またはチャンクを実行する場合、この実行はフックへの呼び出しなしで発生します。

フック関数は継続を持つことができません。つまり、nullでないkでlua_yieldk、lua_pcallk、またはlua_callkを呼び出すことはできません。

フック関数は、次の条件でyieldできます。カウントイベントと行イベントのみがyieldできます。yieldするには、フック関数は、nresultsがゼロ（つまり、値がない）であるlua_yieldを呼び出して実行を終了する必要があります。

lua_sethook

[-0, +0, –]

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

デバッグフック関数を設定します。

引数fはフック関数です。maskは、フックが呼び出されるイベントを指定します。これは、定数LUA_MASKCALL、LUA_MASKRET、LUA_MASKLINE、およびLUA_MASKCOUNTのビットごとのORで形成されます。count引数は、マスクにLUA_MASKCOUNTが含まれている場合にのみ意味があります。各イベントについて、フックは以下で説明するように呼び出されます。

• 呼び出しフック： インタープリターが関数を呼び出すときに呼び出されます。フックは、Luaが新しい関数に入った直後に呼び出されます。
• 戻りフック： インタープリターが関数から戻るときに呼び出されます。フックは、Luaが関数を離れる直前に呼び出されます。
• 行フック： インタープリターが新しいコード行の実行を開始しようとしているとき、またはコード内で（同じ行にでも）戻るときに呼び出されます。このイベントは、LuaがLua関数を実行している間のみ発生します。
• カウントフック： インタープリターがcount命令を実行するたびに呼び出されます。このイベントは、LuaがLua関数を実行している間のみ発生します。

フックは、maskをゼロに設定することで無効になります。

lua_setlocal

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

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

指定されたアクティベーションレコードのローカル変数の値を設定します。スタックの最上位の値を変数に割り当て、その名前を返します。また、スタックから値をポップします。

インデックスがアクティブなローカル変数の数よりも大きい場合は、NULLを返します（何もポップしません）。

パラメータarおよびnは、関数lua_getlocalと同じです。

lua_setupvalue

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

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

クロージャのアップバリューの値を設定します。スタックの最上位の値をアップバリューに割り当て、その名前を返します。また、スタックから値をポップします。

インデックスnがアップバリューの数よりも大きい場合は、NULLを返します（何もポップしません）。

パラメータfuncindexおよびnは、関数lua_getupvalueと同じです。

lua_upvalueid

[-0, +0, –]

void *lua_upvalueid (lua_State *L, int funcindex, int n);

インデックスfuncindexにあるクロージャのn番目のアップバリューの一意の識別子を返します。

これらの固有の識別子により、プログラムは異なるクロージャがアップバリューを共有しているかどうかを確認できます。アップバリューを共有する（つまり、同じ外部ローカル変数にアクセスする）Luaクロージャは、それらのアップバリューインデックスに対して同一のIDを返します。

パラメータfuncindexおよびnは、関数lua_getupvalueと同じですが、nはアップバリューの数よりも大きくすることはできません。

lua_upvaluejoin

[-0, +0, –]

void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
                                    int funcindex2, int n2);

インデックスfuncindex1にあるLuaクロージャのn1番目のアップバリューを、インデックスfuncindex2にあるLuaクロージャのn2番目のアップバリューを参照するようにします。

5 – 補助ライブラリ

補助ライブラリは、CとLuaをインターフェイスするための便利な関数をいくつか提供します。基本的なAPIは、CとLua間のすべての相互作用のためのプリミティブ関数を提供する一方、補助ライブラリはいくつかの一般的なタスクのためのより高レベルの関数を提供します。

補助ライブラリのすべての関数と型は、ヘッダーファイルlauxlib.hで定義され、接頭辞luaL_が付いています。

補助ライブラリのすべての関数は、基本的なAPIの上に構築されているため、そのAPIではできないことは何も提供しません。それにもかかわらず、補助ライブラリを使用すると、コードの一貫性が向上します。

補助ライブラリのいくつかの関数は、内部的にいくつかの追加のスタックスロットを使用します。補助ライブラリの関数が5つ未満のスロットを使用する場合、スタックサイズをチェックしません。十分なスロットがあると単純に想定します。

補助ライブラリのいくつかの関数は、C関数の引数をチェックするために使用されます。エラーメッセージは引数用にフォーマットされているため（例： "bad argument #1"）、これらの関数を他のスタック値に使用しないでください。

luaL_check*と呼ばれる関数は、チェックが満たされない場合は常にエラーを発生させます。

5.1 – 関数と型

ここでは、補助ライブラリのすべての関数と型をアルファベット順にリストします。

luaL_addchar

[-?, +?, m]

void luaL_addchar (luaL_Buffer *B, char c);

バイトcをバッファBに追加します（luaL_Bufferを参照）。

luaL_addgsub

[-?, +?, m]

const void luaL_addgsub (luaL_Buffer *B, const char *s,
                         const char *p, const char *r);

文字列sのコピーをバッファBに追加します（luaL_Bufferを参照）。文字列pの出現箇所を文字列rで置き換えます。

luaL_addlstring

[-?, +?, m]

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

長さlのsが指す文字列をバッファBに追加します（luaL_Bufferを参照）。文字列には埋め込まれたゼロを含めることができます。

luaL_addsize

[-?, +?, –]

void luaL_addsize (luaL_Buffer *B, size_t n);

以前にバッファ領域にコピーされた長さnの文字列をバッファBに追加します（luaL_prepbufferを参照）。

luaL_addstring

[-?, +?, m]

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

sが指すゼロ終端文字列をバッファBに追加します（luaL_Bufferを参照）。

luaL_addvalue

[-?, +?, m]

void luaL_addvalue (luaL_Buffer *B);

スタックの最上位にある値をバッファB（luaL_Bufferを参照）に追加します。値はポップされます。

これは文字列バッファに関する唯一の関数で、スタックに追加する値がスタックにある状態で呼び出すことができます（また、そうする必要があります）。

luaL_argcheck

[-0, +0, v]

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

condが真であるかどうかをチェックします。真でない場合、標準メッセージ（luaL_argerrorを参照）とともにエラーを発生させます。

luaL_argerror

[-0, +0, v]

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

C関数を呼び出した引数argに関する問題を報告するエラーを発生させます。標準メッセージには、コメントとしてextramsgが含まれます。

     bad argument #arg to 'funcname' (extramsg)

この関数は決して戻りません。

luaL_argexpected

[-0, +0, v]

void luaL_argexpected (lua_State *L,
                       int cond,
                       int arg,
                       const char *tname);

condが真であるかどうかをチェックします。真でない場合、標準メッセージ（luaL_typeerrorを参照）とともに引数argの型に関するエラーを発生させます。

luaL_Buffer

typedef struct luaL_Buffer luaL_Buffer;

文字列バッファの型。

文字列バッファを使用すると、CコードでLua文字列を段階的に構築できます。その使用パターンは以下のとおりです。

• まず、luaL_Buffer型の変数bを宣言します。
• 次に、luaL_buffinit(L, &b)を呼び出して初期化します。
• 次に、luaL_add*関数を呼び出して、文字列の断片をバッファに追加します。
• 最後に、luaL_pushresult(&b)を呼び出して完了します。この呼び出しは、最終的な文字列をスタックの最上位に残します。

結果の文字列の最大サイズを事前に知っている場合は、次のようにバッファを使用できます。

• まず、luaL_Buffer型の変数bを宣言します。
• 次に、luaL_buffinitsize(L, &b, sz)を呼び出して初期化し、サイズszの領域を事前割り当てします。
• 次に、その領域に文字列を生成します。
• 最後に、luaL_pushresultsize(&b, sz)を呼び出して完了します。szは、その領域にコピーされた結果の文字列の合計サイズです（事前割り当てされたサイズ以下になる可能性があります）。

通常の操作中、文字列バッファは可変数のスタックスロットを使用します。そのため、バッファを使用している間は、スタックの最上位がどこにあるかわからないことを前提とする必要があります。スタックは、その使用がバランスが取れている限り、バッファ操作への連続した呼び出しの間で使用できます。つまり、バッファ操作を呼び出すとき、スタックは前のバッファ操作直後と同じレベルにある必要があります。（この規則の唯一の例外はluaL_addvalueです。）luaL_pushresultを呼び出した後、スタックはバッファが初期化されたときと同じレベルに戻り、さらにその最上位に最終的な文字列が追加されます。

luaL_buffaddr

[-0, +0, –]

char *luaL_buffaddr (luaL_Buffer *B);

バッファB（luaL_Bufferを参照）の現在の内容のアドレスを返します。バッファへの追加は、このアドレスを無効にする可能性があることに注意してください。

luaL_buffinit

[-0, +?, –]

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

バッファB（luaL_Bufferを参照）を初期化します。この関数は領域を割り当てません。バッファは変数として宣言する必要があります。

luaL_bufflen

[-0, +0, –]

size_t luaL_bufflen (luaL_Buffer *B);

バッファB（luaL_Bufferを参照）の現在の内容の長さを返します。

luaL_buffinitsize

[-?, +?, m]

char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);

luaL_buffinit, luaL_prepbuffsizeのシーケンスと同等です。

luaL_buffsub

[-?, +?, –]

void luaL_buffsub (luaL_Buffer *B, int n);

バッファB（luaL_Bufferを参照）からnバイトを削除します。バッファには少なくともそれだけのバイト数が必要です。

luaL_callmeta

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

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

メタメソッドを呼び出します。

インデックスobjにあるオブジェクトがメタテーブルを持ち、このメタテーブルにフィールドeがある場合、この関数はこのフィールドを呼び出し、オブジェクトを唯一の引数として渡します。この場合、この関数はtrueを返し、呼び出しによって返された値をスタックにプッシュします。メタテーブルがない場合、またはメタメソッドがない場合、この関数は値をスタックにプッシュせずにfalseを返します。

luaL_checkany

[-0, +0, v]

void luaL_checkany (lua_State *L, int arg);

関数が位置argに任意の型（nilを含む）の引数を持っているかどうかをチェックします。

luaL_checkinteger

[-0, +0, v]

lua_Integer luaL_checkinteger (lua_State *L, int arg);

関数引数argが整数である（または整数に変換できる）かどうかをチェックし、この整数を返します。

luaL_checklstring

[-0, +0, v]

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

関数引数argが文字列であるかどうかをチェックし、この文字列を返します。lがNULLでない場合は、その参照を文字列の長さで埋めます。

この関数は、結果を取得するためにlua_tolstringを使用するため、その関数のすべての変換と注意点がここで適用されます。

luaL_checknumber

[-0, +0, v]

lua_Number luaL_checknumber (lua_State *L, int arg);

関数引数argが数値であるかどうかをチェックし、この数値をlua_Numberに変換して返します。

luaL_checkoption

[-0, +0, v]

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

関数引数argが文字列であるかどうかをチェックし、この文字列を配列lst（NULL終端である必要があります）で検索します。文字列が見つかった配列のインデックスを返します。引数が文字列でない場合、または文字列が見つからない場合は、エラーを発生させます。

defがNULLでない場合、この関数は、引数argがない場合、またはこの引数がnilの場合に、defをデフォルト値として使用します。

これは、文字列をC列挙型にマッピングするのに役立つ関数です。（Luaライブラリでの一般的な規約は、オプションを選択するために数値の代わりに文字列を使用することです。）

luaL_checkstack

[-0, +0, v]

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

スタックサイズをtop + sz要素まで増やします。スタックがそのサイズまで増やせない場合は、エラーを発生させます。msgは、エラーメッセージに追加するテキスト（追加のテキストがない場合はNULL）です。

luaL_checkstring

[-0, +0, v]

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

関数引数argが文字列であるかどうかをチェックし、この文字列を返します。

この関数は、結果を取得するためにlua_tolstringを使用するため、その関数のすべての変換と注意点がここで適用されます。

luaL_checktype

[-0, +0, v]

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

関数引数argが型tを持っているかどうかをチェックします。tの型のエンコーディングについてはlua_typeを参照してください。

luaL_checkudata

[-0, +0, v]

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

関数引数argが型tname（luaL_newmetatableを参照）のuserdataであるかどうかをチェックし、userdataのメモリブロックアドレス（lua_touserdataを参照）を返します。

luaL_checkversion

[-0, +0, v]

void luaL_checkversion (lua_State *L);

呼び出しを行うコードと呼び出されているLuaライブラリが、同じバージョンのLuaと、同じ数値型を使用しているかどうかをチェックします。

luaL_dofile

[-0, +?, m]

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

指定されたファイルをロードして実行します。これは、次のマクロとして定義されます。

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

エラーがない場合は0（LUA_OK）を返し、エラーの場合は1を返します。

luaL_dostring

[-0, +?, –]

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

指定された文字列をロードして実行します。これは、次のマクロとして定義されます。

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

エラーがない場合は0（LUA_OK）を返し、エラーの場合は1を返します。

luaL_error

[-0, +0, v]

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

エラーを発生させます。エラーメッセージの形式は、lua_pushfstringと同じルールに従って、fmtと追加の引数によって指定されます。また、メッセージの先頭に、エラーが発生したファイル名と行番号を追加します（この情報が利用可能な場合）。

この関数は決して戻りませんが、C関数ではreturn luaL_error(args)として使用するのが慣例です。

luaL_execresult

[-0, +3, m]

int luaL_execresult (lua_State *L, int stat);

この関数は、標準ライブラリ（os.executeおよびio.close）のプロセス関連関数の戻り値を生成します。

luaL_fileresult

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

int luaL_fileresult (lua_State *L, int stat, const char *fname);

この関数は、標準ライブラリ（io.open、os.rename、file:seekなど）のファイル関連関数の戻り値を生成します。

luaL_getmetafield

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

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

インデックスobjにあるオブジェクトのメタテーブルからフィールドeをスタックにプッシュし、プッシュされた値の型を返します。オブジェクトにメタテーブルがない場合、またはメタテーブルにこのフィールドがない場合は、何もプッシュせずにLUA_TNILを返します。

luaL_getmetatable

[-0, +1, m]

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

レジストリ内の名前tnameに関連付けられたメタテーブル（luaL_newmetatableを参照）をスタックにプッシュします。その名前に関連付けられたメタテーブルがない場合はnilをプッシュします。プッシュされた値の型を返します。

luaL_getsubtable

[-0, +1, e]

int luaL_getsubtable (lua_State *L, int idx, const char *fname);

インデックスidxにある値tにおいて、t[fname]がテーブルであることを確認し、そのテーブルをスタックにプッシュします。そこに以前のテーブルがある場合はtrueを返し、新しいテーブルを作成した場合はfalseを返します。

luaL_gsub

[-0, +1, m]

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

文字列sのコピーを作成し、文字列pの出現箇所をすべて文字列rに置き換えます。結果の文字列をスタックにプッシュして返します。

luaL_len

[-0, +0, e]

lua_Integer luaL_len (lua_State *L, int index);

指定されたインデックスにある値の「長さ」を数値として返します。これはLuaの '#' 演算子（§3.4.7を参照）と同等です。操作の結果が整数でない場合は、エラーを発生させます。（このケースは、メタメソッドを通じてのみ発生する可能性があります。）

luaL_loadbuffer

[-0, +1, –]

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

modeがNULLであるluaL_loadbufferxと同等です。

luaL_loadbufferx

[-0, +1, –]

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

バッファをLuaチャンクとしてロードします。この関数は、lua_loadを使用して、サイズszのbuffによって指されるバッファ内のチャンクをロードします。

この関数は、lua_loadと同じ結果を返します。nameは、デバッグ情報とエラーメッセージに使用されるチャンク名です。文字列modeは、関数lua_loadの場合と同様に機能します。

luaL_loadfile

[-0, +1, m]

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

modeがNULLであるluaL_loadfilexと同等です。

luaL_loadfilex

[-0, +1, m]

int luaL_loadfilex (lua_State *L, const char *filename,
                                            const char *mode);

ファイルをLuaチャンクとしてロードします。この関数は、lua_loadを使用して、filenameという名前のファイル内のチャンクをロードします。filenameがNULLの場合、標準入力からロードします。ファイルの最初の行が#で始まる場合は無視されます。

文字列modeは、関数lua_loadの場合と同様に機能します。

この関数は、lua_loadと同じ結果を返します。ファイル関連のエラーの場合は、LUA_ERRFILEを返します。

lua_loadと同様に、この関数はチャンクをロードするだけで、実行はしません。

luaL_loadstring

[-0, +1, –]

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

文字列をLuaチャンクとしてロードします。この関数は、lua_loadを使用して、NULL終端文字列s内のチャンクをロードします。

この関数は、lua_loadと同じ結果を返します。

lua_loadと同様に、この関数はチャンクをロードするだけで、実行はしません。

luaL_newlib

[-0, +1, m]

void luaL_newlib (lua_State *L, const luaL_Reg l[]);

新しいテーブルを作成し、リストl内の関数を登録します。

これは、次のマクロとして実装されます。

     (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))

配列lは、実際の配列である必要があり、ポインタであってはなりません。

luaL_newlibtable

[-0, +1, m]

void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);

配列l内のすべてのエントリを格納するために最適化されたサイズで新しいテーブルを作成します（ただし、実際には格納しません）。これは、luaL_setfuncs（luaL_newlibを参照）と組み合わせて使用​​することを目的としています。

これはマクロとして実装されます。配列lは、実際の配列である必要があり、ポインタであってはなりません。

luaL_newmetatable

[-0, +1, m]

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

レジストリにすでにキーtnameがある場合は0を返します。そうでない場合は、userdataのメタテーブルとして使用する新しいテーブルを作成し、この新しいテーブルにペア__name = tnameを追加し、レジストリにペア[tname] = new tableを追加して1を返します。

どちらの場合も、この関数は、レジストリ内のtnameに関連付けられた最終的な値をスタックにプッシュします。

luaL_newstate

[-0, +0, –]

lua_State *luaL_newstate (void);

新しいLuaステートを作成します。ISO Cのメモリ割り当て関数に基づくアロケータでlua_newstateを呼び出し、その後、標準エラー出力にメッセージを出力する警告関数とパニック関数（§4.4を参照）を設定します。

新しいステートを返します。メモリ割り当てエラーが発生した場合はNULLを返します。

luaL_openlibs

[-0, +0, e]

void luaL_openlibs (lua_State *L);

与えられたステートにすべての標準Luaライブラリを開きます。

luaL_opt

[-0, +0, –]

T luaL_opt (L, func, arg, dflt);

このマクロは次のように定義されます。

     (lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))

言葉で言うと、引数argがnilまたは存在しない場合、マクロの結果はデフォルトのdfltになります。それ以外の場合は、ステートLと引数インデックスargを引数としてfuncを呼び出した結果になります。必要な場合にのみ式dfltが評価されることに注意してください。

luaL_optinteger

[-0, +0, v]

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

関数引数argが整数である（または整数に変換可能である）場合、この整数を返します。この引数が存在しないか、nilの場合は、dを返します。それ以外の場合は、エラーを発生させます。

luaL_optlstring

[-0, +0, v]

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

関数引数argが文字列である場合、この文字列を返します。この引数が存在しないか、nilの場合は、dを返します。それ以外の場合は、エラーを発生させます。

lがNULLでない場合、その参照先を結果の長さで埋めます。結果がNULL（dを返し、d == NULLの場合のみ可能）の場合、その長さはゼロとみなされます。

この関数は、結果を取得するためにlua_tolstringを使用するため、その関数のすべての変換と注意点がここで適用されます。

luaL_optnumber

[-0, +0, v]

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

関数引数argが数値である場合、この数値をlua_Numberとして返します。この引数が存在しないか、nilの場合は、dを返します。それ以外の場合は、エラーを発生させます。

luaL_optstring

[-0, +0, v]

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

関数引数argが文字列である場合、この文字列を返します。この引数が存在しないか、nilの場合は、dを返します。それ以外の場合は、エラーを発生させます。

luaL_prepbuffer

[-?, +?, m]

char *luaL_prepbuffer (luaL_Buffer *B);

定義済みのサイズLUAL_BUFFERSIZEでluaL_prepbuffsizeと同等です。

luaL_prepbuffsize

[-?, +?, m]

char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);

バッファB（luaL_Bufferを参照）に追加する文字列をコピーできるサイズszのスペースのアドレスを返します。このスペースに文字列をコピーした後、文字列のサイズでluaL_addsizeを呼び出して、実際にバッファに追加する必要があります。

luaL_pushfail

[-0, +1, –]

void luaL_pushfail (lua_State *L);

スタックにfail値をプッシュします（§6を参照）。

luaL_pushresult

[-?, +1, m]

void luaL_pushresult (luaL_Buffer *B);

バッファBの使用を終了し、最終的な文字列をスタックの最上部に残します。

luaL_pushresultsize

[-?, +1, m]

void luaL_pushresultsize (luaL_Buffer *B, size_t sz);

シーケンスluaL_addsize、luaL_pushresultと同等です。

luaL_ref

[-1, +0, m]

int luaL_ref (lua_State *L, int t);

スタックの一番上にあるオブジェクトに対する参照を、インデックスtにあるテーブル内に作成して返します（そしてオブジェクトをポップします）。

参照は一意の整数キーです。テーブルtに整数キーを手動で追加しない限り、luaL_refは返されるキーの一意性を保証します。参照rで参照されるオブジェクトを取得するには、lua_rawgeti(L, t, 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_setfuncsによって登録される関数の配列の型です。nameは関数名であり、funcは関数へのポインタです。luaL_Regの配列は、nameとfuncの両方がNULLである番兵エントリで終わる必要があります。

luaL_requiref

[-0, +1, e]

void luaL_requiref (lua_State *L, const char *modname,
                    lua_CFunction openf, int glb);

package.loaded[modname]がtrueでない場合、文字列modnameを引数として関数openfを呼び出し、requireを介して関数が呼び出されたかのように、呼び出し結果をpackage.loaded[modname]に設定します。

glbがtrueの場合、モジュールをグローバルmodnameにも保存します。

スタックにモジュールのコピーを残します。

luaL_setfuncs

[-nup, +0, m]

void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);

配列l（luaL_Regを参照）内のすべての関数を、スタックの最上部にあるテーブル（オプションのアップバリューの下、次を参照）に登録します。

nupがゼロでない場合、すべての関数はnup個のアップバリューで作成され、ライブラリテーブルの一番上にスタックにプッシュされたnup個の値のコピーで初期化されます。これらの値は、登録後にスタックからポップされます。

NULL値を持つ関数は、falseで埋められるプレースホルダを表します。

luaL_setmetatable

[-0, +0, –]

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

スタックの最上部にあるオブジェクトのメタテーブルを、レジストリ内の名前tnameに関連付けられたメタテーブルとして設定します（luaL_newmetatableを参照）。

luaL_Stream

typedef struct luaL_Stream {
  FILE *f;
  lua_CFunction closef;
} luaL_Stream;

標準I/Oライブラリで使用されるファイルハンドルの標準表現です。

ファイルハンドルは、LUA_FILEHANDLEというメタテーブルを持つフルユーザーデータとして実装されます（LUA_FILEHANDLEは実際のメタテーブルの名前を持つマクロです）。メタテーブルはI/Oライブラリによって作成されます（luaL_newmetatableを参照）。

このユーザーデータは構造体luaL_Streamで始まる必要があり、この初期構造体の後に他のデータを含めることができます。フィールドfは対応するCストリームを指します（または、不完全に作成されたハンドルを示すためにNULLにすることもできます）。フィールドclosefは、ハンドルが閉じられたとき、または収集されたときにストリームを閉じるために呼び出されるLua関数を指します。この関数は、ファイルハンドルを唯一の引数として受け取り、成功の場合はtrue値、エラーの場合はfalse値とエラーメッセージを返す必要があります。Luaがこのフィールドを呼び出すと、ハンドルが閉じられたことを示すために、フィールド値をNULLに変更します。

luaL_testudata

[-0, +0, m]

void *luaL_testudata (lua_State *L, int arg, const char *tname);

この関数は、テストが失敗した場合にエラーを発生させる代わりにNULLを返すことを除いて、luaL_checkudataのように機能します。

luaL_tolstring

[-0, +1, e]

const char *luaL_tolstring (lua_State *L, int idx, size_t *len);

指定されたインデックスにある任意のLua値を、妥当な形式のC文字列に変換します。結果の文字列はスタックにプッシュされ、関数からも返されます（§4.1.3を参照）。lenがNULLでない場合、関数は*lenに文字列の長さも設定します。

値に__tostringフィールドを持つメタテーブルがある場合、luaL_tolstringは値を引数として対応するメタメソッドを呼び出し、呼び出しの結果を結果として使用します。

luaL_traceback

[-0, +1, m]

void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
                     int level);

スタックL1のトレースバックを作成してプッシュします。msgがNULLでない場合、トレースバックの先頭に追加されます。levelパラメータは、トレースバックを開始するレベルを示します。

luaL_typeerror

[-0, +0, v]

int luaL_typeerror (lua_State *L, int arg, const char *tname);

標準メッセージを使用して、それを呼び出したC関数の引数argに対して型エラーを発生させます。tnameは、予期される型の「名前」です。この関数は決して返りません。

luaL_typename

[-0, +0, –]

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

指定されたインデックスにある値の型の名前を返します。

luaL_unref

[-0, +0, –]

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

インデックスtにあるテーブルから参照refを解放します（luaL_refを参照）。エントリはテーブルから削除されるため、参照されているオブジェクトを収集できます。参照refも再利用できるように解放されます。

refがLUA_NOREFまたはLUA_REFNILの場合、luaL_unrefは何もしません。

luaL_where

[-0, +1, m]

void luaL_where (lua_State *L, int lvl);

スタックに、コールスタック内のレベルlvlでのコントロールの現在の位置を識別する文字列をプッシュします。通常、この文字列は次の形式です。

     chunkname:currentline:

レベル 0は実行中の関数、レベル 1は実行中の関数を呼び出した関数などです。

この関数は、エラーメッセージのプレフィックスを構築するために使用されます。

6 – 標準ライブラリ

標準Luaライブラリは、C APIを介してCで実装された便利な関数を提供します。これらの関数の中には、言語に不可欠なサービスを提供するもの（例：typeとgetmetatable）があります。その他は、外部サービス（例：I/O）へのアクセスを提供します。また、Lua自体で実装できるものもありますが、さまざまな理由でCでの実装に値するものもあります（例：table.sort）。

すべてのライブラリは公式のC APIを介して実装され、個別のC モジュールとして提供されます。特に断りのない限り、これらのライブラリ関数は、その引数の数を予期されるパラメータに調整しません。たとえば、foo(arg)としてドキュメント化された関数は、引数なしで呼び出すべきではありません。

failという表記は、何らかの失敗を表すfalse値を意味します。（現在、failはnilと等しいですが、将来のバージョンでは変更される可能性があります。推奨されるのは、(status == nil)の代わりに、常に(not status)でこれらの関数の成功をテストすることです。）

現在、Luaには次の標準ライブラリがあります。

• 基本ライブラリ（§6.1）;
• コルーチンライブラリ（§6.2）;
• パッケージライブラリ（§6.3）;
• 文字列操作（§6.4）;
• 基本的なUTF-8サポート（§6.5）;
• テーブル操作（§6.6）;
• 数学関数（§6.7）（sin、logなど）;
• 入出力（§6.8）;
• オペレーティングシステム機能（§6.9）;
• デバッグ機能（§6.10）。

基本ライブラリとパッケージライブラリを除いて、各ライブラリは、そのすべての関数をグローバルテーブルのフィールドとして、またはそのオブジェクトのメソッドとして提供します。

これらのライブラリにアクセスするには、C ホストプログラムは、すべての標準ライブラリを開くluaL_openlibs関数を呼び出す必要があります。または、ホストプログラムは、luaopen_base（基本ライブラリの場合）、luaopen_package（パッケージライブラリの場合）、luaopen_coroutine（コルーチンライブラリの場合）、luaopen_string（文字列ライブラリの場合）、luaopen_utf8（UTF-8ライブラリの場合）、luaopen_table（テーブルライブラリの場合）、luaopen_math（数学ライブラリの場合）、luaopen_io（I/Oライブラリの場合）、luaopen_os（オペレーティングシステムライブラリの場合）、およびluaopen_debug（デバッグライブラリの場合）を呼び出すために、luaL_requirefを使用して個別に開くことができます。これらの関数はlualib.hで宣言されています。

6.1 – 基本関数

基本ライブラリは、Luaへのコア関数を提供します。このライブラリをアプリケーションに含めない場合は、その機能の一部に実装を提供する必要があるかどうかを注意深く確認する必要があります。

assert (v [, message])

引数vの値がfalse（つまり、nilまたはfalse）の場合、エラーを発生させます。それ以外の場合は、すべての引数を返します。エラーの場合、messageはエラーオブジェクトです。存在しない場合は、デフォルトで"assertion failed!"になります。

collectgarbage ([opt [, arg]])

この関数は、ガベージコレクタへの汎用インターフェイスです。最初の引数optに従ってさまざまな関数を実行します。

• "collect": 完全なガベージコレクションサイクルを実行します。これはデフォルトのオプションです。
• "stop": ガベージコレクタの自動実行を停止します。コレクタは、明示的に呼び出された場合にのみ、再起動するまでの間実行されます。
• "restart": ガベージコレクタの自動実行を再開します。
• "count": Luaで使用されている総メモリをKbytes単位で返します。この値には小数部があり、1024を掛けると、Luaで使用されている正確なバイト数が得られます。
• "step": ガベージコレクションステップを実行します。ステップの「サイズ」はargによって制御されます。ゼロ値の場合、コレクタは1つの基本的な（不可分な）ステップを実行します。ゼロ以外の値の場合、コレクタはLuaによってその量のメモリ（Kbytes単位）が割り当てられたかのように実行します。ステップがコレクションサイクルを終了した場合はtrueを返します。
• "isrunning": コレクタが実行中（つまり、停止していない）かどうかを示すブール値を返します。
• "incremental": コレクタモードをインクリメンタルに変更します。このオプションの後には3つの数字が続きます。ガベージコレクタの一時停止時間、ステップ乗数、ステップサイズです（§2.5.1を参照）。0 はその値を変更しないことを意味します。
• "generational": コレクタモードを世代別に変更します。このオプションの後には2つの数字が続きます。ガベージコレクタのマイナー乗数とメジャー乗数です（§2.5.2を参照）。0 はその値を変更しないことを意味します。

ガベージコレクションとこれらのオプションの詳細については、§2.5を参照してください。

この関数はファイナライザーによって呼び出されるべきではありません。

dofile ([filename])

error (message [, level])

通常、error は、メッセージが文字列の場合、メッセージの先頭にエラー位置に関する情報を追加します。level 引数は、エラー位置を取得する方法を指定します。level 1（デフォルト）では、エラー位置は error 関数が呼び出された場所です。Level 2 は、error を呼び出した関数が呼び出された場所をエラーとして示します。以降同様です。level 0 を渡すと、メッセージへのエラー位置情報の追加を回避できます。

_G

getmetatable (object)

object がメタテーブルを持っていない場合は、nil を返します。それ以外の場合で、オブジェクトのメタテーブルに __metatable フィールドがある場合は、関連付けられた値を返します。それ以外の場合は、指定されたオブジェクトのメタテーブルを返します。

ipairs (t)

3つの値（イテレータ関数、テーブル t、および 0）を返すため、次の構造

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

は、欠落した最初のインデックスまで、（1,t[1]）、（2,t[2]）などのキーと値のペアを反復処理します。

load (chunk [, chunkname [, mode [, env]]])

チャンクをロードします。

chunk が文字列の場合、チャンクはこの文字列です。chunk が関数の場合、load はチャンクの断片を取得するために繰り返し呼び出します。chunk の各呼び出しは、以前の結果と連結する文字列を返す必要があります。空の文字列、nil、または値がない場合は、チャンクの終わりを示します。

構文エラーがない場合、load はコンパイルされたチャンクを関数として返します。それ以外の場合は、fail とエラーメッセージを返します。

メインチャンクをロードすると、結果の関数には常に1つのアップバリュー（_ENV 変数）があります（§2.2を参照）。ただし、関数から作成されたバイナリチャンクをロードした場合（string.dumpを参照）、結果の関数は任意の数のアップバリューを持つ可能性があり、最初のアップバリューが _ENV 変数であるという保証はありません。（メインでない関数は _ENV アップバリューを持たない場合もあります。）

いずれの場合も、結果の関数にアップバリューがある場合、その最初のアップバリューは、パラメータが指定されている場合は env の値に設定され、それ以外の場合はグローバル環境の値に設定されます。その他のアップバリューは nil で初期化されます。すべてのアップバリューは新しく、他の関数とは共有されません。

chunkname は、エラーメッセージおよびデバッグ情報用のチャンクの名前として使用されます（§4.7を参照）。省略した場合、chunk が文字列の場合は chunk、それ以外の場合は "=(load)" がデフォルトになります。

文字列 mode は、チャンクがテキストまたはバイナリ（つまり、プリコンパイルされたチャンク）のどちらにできるかを制御します。文字列 "b"（バイナリチャンクのみ）、"t"（テキストチャンクのみ）、または "bt"（バイナリとテキストの両方）にすることができます。デフォルトは "bt" です。

不正な形式のバイナリチャンクをロードしても安全です。load は適切なエラーを示します。ただし、Lua はバイナリチャンク内のコードの一貫性をチェックしません。悪意を持って作成されたバイトコードを実行すると、インタプリタがクラッシュする可能性があります。

loadfile ([filename [, mode [, env]]])

load と同様ですが、チャンクをファイル filename から、またはファイル名が指定されていない場合は標準入力から取得します。

next (table [, index])

プログラムがテーブルのすべてのフィールドを走査できるようにします。最初の引数はテーブルで、2番目の引数はこのテーブルのインデックスです。next を呼び出すと、テーブルの次のインデックスとその関連付けられた値が返されます。2番目の引数として nil を渡して呼び出すと、next は初期インデックスとその関連付けられた値を返します。最後のインデックス、または空のテーブルで nil を渡して呼び出すと、next は nil を返します。2番目の引数が省略された場合、nil として解釈されます。特に、next(t) を使用して、テーブルが空かどうかを確認できます。

インデックスが列挙される順序は、数値インデックスであっても指定されていません。（テーブルを数値順に走査するには、数値の for を使用します。）

走査中にテーブルの存在しないフィールドに値を代入しないでください。ただし、既存のフィールドは変更できます。特に、既存のフィールドを nil に設定できます。

pairs (t)

t にメタメソッド __pairs がある場合、t を引数としてそれを呼び出し、呼び出しからの最初の 3 つの結果を返します。

それ以外の場合は、3 つの値を返します。 next 関数、テーブル t、および nil を返すため、次の構造

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

は、テーブル t のすべてのキーと値のペアを反復処理します。

テーブルを走査中に変更する場合の注意点については、next 関数を参照してください。

pcall (f [, arg1, ···])

保護モードで、指定された引数を使用して関数 f を呼び出します。これは、f 内のエラーが伝播されないことを意味します。代わりに、pcall はエラーをキャッチし、ステータスコードを返します。最初の結果はステータスコード（ブール値）であり、呼び出しがエラーなしで成功した場合は true です。その場合、pcall はこの最初の結果の後、呼び出しからのすべての結果も返します。エラーが発生した場合、pcall は false とエラーオブジェクトを返します。pcall によってキャッチされたエラーは、メッセージハンドラーを呼び出さないことに注意してください。

print (···)

print 関数は、フォーマットされた出力を目的としたものではなく、たとえばデバッグのために値をすばやく表示するためのものです。出力を完全に制御するには、string.format と io.write を使用してください。

rawequal (v1, v2)

rawget (table, index)

rawlen (v)

rawset (table, index, value)

この関数は table を返します。

select (index, ···)

index が数値の場合、引数番号 index 以降のすべての引数を返します。負の数は末尾からインデックス付けされます（-1 は最後の引数です）。それ以外の場合、index は文字列 "#" である必要があり、select は受信した余分な引数の合計数を返します。

setmetatable (table, metatable)

指定されたテーブルのメタテーブルを設定します。metatable が nil の場合、指定されたテーブルのメタテーブルを削除します。元のメタテーブルに __metatable フィールドがある場合は、エラーが発生します。

この関数は table を返します。

Lua コードから他の型のメタテーブルを変更するには、デバッグライブラリを使用する必要があります（§6.10）。

tonumber (e [, base])

base を指定せずに呼び出すと、tonumber は引数を数値に変換しようとします。引数がすでに数値であるか、数値に変換可能な文字列である場合、tonumber はこの数値を返します。それ以外の場合は、fail を返します。

文字列の変換は、Lua の字句規則に従って（§3.1を参照）、整数または浮動小数点数になる可能性があります。文字列には、先頭と末尾のスペースと符号を含めることができます。

base を指定して呼び出すと、e はその基数で整数数値として解釈される文字列である必要があります。基数は、2〜36 の任意の整数にすることができます。10 を超える基数では、文字 'A'（大文字または小文字）は 10 を表し、'B' は 11 を表し、以下同様に 'Z' は 35 を表します。文字列 e が指定された基数で有効な数値ではない場合、関数は fail を返します。

tostring (v)

任意の型の値を受け取り、人間が読める形式の文字列に変換します。

v のメタテーブルに __tostring フィールドがある場合、tostring は v を引数として対応する値を呼び出し、その呼び出しの結果を結果として使用します。それ以外の場合、v のメタテーブルに文字列値を持つ __name フィールドがある場合、tostring はその文字列を最終結果で使用する可能性があります。

数値がどのように変換されるかを完全に制御するには、string.format を使用してください。

type (v)

唯一の引数の型を、文字列としてエンコードして返します。この関数の可能な結果は、"nil"（値 nil ではなく文字列）、"number"、"string"、"boolean"、"table"、"function"、"thread"、および "userdata" です。

_VERSION

実行中の Lua バージョンを含む文字列を保持するグローバル変数（関数ではありません）。この変数の現在の値は "Lua 5.4" です。

warn (msg1, ···)

すべての引数（文字列である必要があります）の連結で構成されるメッセージを含む警告を発行します。

慣例により、'@' で始まる 1 つのメッセージは、警告システム自体へのメッセージである制御メッセージであることを意図しています。特に、Lua の標準警告関数は、警告の出力を停止する "@off" と、出力を（再）開始する "@on" という制御メッセージを認識します。不明な制御メッセージは無視されます。

xpcall (f, msgh [, arg1, ···])

この関数は、新しいメッセージハンドラ msgh を設定することを除いて、pcall と似ています。

6.2 – コルーチン操作

このライブラリは、coroutine テーブルに含まれるコルーチンを操作する操作で構成されています。コルーチンの概要については、§2.6 を参照してください。

coroutine.close (co)

コルーチン co を閉じます。つまり、保留中のクローズ対象のすべての変数を閉じ、コルーチンをデッド状態にします。指定されたコルーチンは、デッド状態または中断状態である必要があります。エラーが発生した場合（コルーチンを停止させた元のエラー、またはクローズメソッドでのエラー）、false とエラーオブジェクトを返します。それ以外の場合は、true を返します。

coroutine.create (f)

本体が f の新しいコルーチンを作成します。f は関数である必要があります。この新しいコルーチンを、タイプが "thread" のオブジェクトとして返します。

coroutine.isyieldable ([co])

コルーチン co が yield できる場合は true を返します。co のデフォルトは、実行中のコルーチンです。

コルーチンは、メインスレッドではなく、yield 不可能な C 関数内にない場合に yield 可能です。

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

コルーチン co の実行を開始または再開します。コルーチンを最初に再開すると、その本体の実行が開始されます。値 val1, ... は、本体関数の引数として渡されます。コルーチンが yield している場合、resume はそれを再起動します。値 val1, ... は、yield からの結果として渡されます。

コルーチンがエラーなく実行された場合、resume は true に加えて、yield に渡された任意の値（コルーチンが yield する場合）、または本体関数によって返された任意の値（コルーチンが終了する場合）を返します。エラーが発生した場合、resume は false とエラーメッセージを返します。

coroutine.running ()

実行中のコルーチンとブール値を返します。実行中のコルーチンがメインのものである場合は true を返します。

coroutine.status (co)

コルーチン co のステータスを文字列として返します。コルーチンが実行中の場合（つまり、status を呼び出したもの）、"running"。コルーチンが yield の呼び出しで中断されている場合、またはまだ実行を開始していない場合は、"suspended"。コルーチンがアクティブだが実行されていない場合（つまり、別のコルーチンを再開している場合）、"normal"。コルーチンが本体関数を終了した場合、またはエラーで停止した場合は、"dead"。

coroutine.wrap (f)

本体が f の新しいコルーチンを作成します。f は関数である必要があります。呼び出されるたびにコルーチンを再開する関数を返します。この関数に渡された引数は、resume への追加引数として扱われます。この関数は、最初のブール値を除いて、resume によって返されるのと同じ値を返します。エラーが発生した場合、関数はコルーチンを閉じ、エラーを伝播します。

coroutine.yield (···)

呼び出し元のコルーチンの実行を中断します。yield への引数は、resume への追加の結果として渡されます。

6.3 – モジュール

package ライブラリは、Lua でモジュールをロードするための基本的な機能を提供します。グローバル環境に 1 つの関数 require を直接エクスポートします。他のすべては、package テーブルにエクスポートされます。

require (modname)

指定されたモジュールをロードします。この関数は、package.loaded テーブルを調べて、modname がすでにロードされているかどうかを判断することから開始します。ロードされている場合、require は package.loaded[modname] に格納されている値を返します。（この場合、2 番目の結果がないことは、この呼び出しがモジュールをロードする必要がなかったことを示します。）それ以外の場合は、モジュールのローダーを検索しようとします。

ローダーを検索するために、require は package.searchers テーブルによってガイドされます。このテーブルの各項目は検索関数であり、特定の方法でモジュールを検索します。このテーブルを変更することにより、require がモジュールを検索する方法を変更できます。以下の説明は、package.searchers のデフォルト構成に基づいています。

まず、require は package.preload[modname] をクエリします。値がある場合、この値（関数である必要があります）がローダーです。それ以外の場合、require は package.path に格納されているパスを使用して Lua ローダーを検索します。それも失敗した場合、package.cpath に格納されているパスを使用して C ローダーを検索します。それも失敗した場合、オールインワンローダーを試みます（package.searchers を参照）。

ローダーが見つかると、require はローダーを 2 つの引数、modname と追加の値（ローダーデータ）を付けて呼び出します。ローダーデータは、モジュールにとって有用な任意の値を指定できます。デフォルトの検索機能の場合、ローダーが見つかった場所を示します。（たとえば、ローダーがファイルから来た場合、この追加の値はファイルパスです。）ローダーが nil 以外の値を返す場合、require は返された値を package.loaded[modname] に割り当てます。ローダーが nil 以外の値を返さず、package.loaded[modname] に値を割り当てていない場合、require はこのエントリに true を割り当てます。いずれの場合も、require は package.loaded[modname] の最終値を返します。その値に加えて、require は 2 番目の結果として、検索機能によって返されたローダーデータも返します。これは、require がモジュールをどのように見つけたかを示します。

モジュールのロードまたは実行中にエラーが発生した場合、またはモジュールのローダーが見つからない場合、require はエラーを発生させます。

package.config

パッケージのコンパイル時の構成を記述する文字列。この文字列は、行のシーケンスです。

• 最初の行は、ディレクトリ区切り文字の文字列です。デフォルトは、Windows の場合は '\'、他のすべてのシステムの場合は '/' です。
• 2 番目の行は、パス内のテンプレートを区切る文字です。デフォルトは ';' です。
• 3 番目の行は、テンプレート内の置換ポイントをマークする文字列です。デフォルトは '?' です。
• 4 番目の行は、Windows のパスで、実行可能ファイルのディレクトリに置き換えられる文字列です。デフォルトは '!' です。
• 5 番目の行は、luaopen_ 関数名を構築するときに、その後のすべてのテキストを無視するためのマークです。デフォルトは '-' です。

package.cpath

require が C ローダーを検索するために使用するパスを含む文字列。

Lua は、環境変数 LUA_CPATH_5_4、または環境変数 LUA_CPATH、または luaconf.h で定義されたデフォルトのパスを使用して、Lua パス package.path を初期化するのと同じ方法で C パス package.cpath を初期化します。

package.loaded

require がすでにロードされているモジュールを制御するために使用するテーブル。モジュール modname を require するとき、package.loaded[modname] が false でない場合、require はそこに格納されている値を返します。

この変数は、実際のテーブルへの参照にすぎません。この変数への代入は、require が使用するテーブルを変更しません。実際のテーブルは、C レジストリ（§4.3 を参照）に格納され、キー LUA_LOADED_TABLE（文字列）でインデックス付けされます。

package.loadlib (libname, funcname)

ホストプログラムを C ライブラリ libname に動的にリンクします。

funcname が "*" の場合、ライブラリへのリンクのみを行い、ライブラリによってエクスポートされたシンボルを、動的にリンクされた他のライブラリで使用できるようにします。それ以外の場合は、ライブラリ内の関数 funcname を検索し、この関数を C 関数として返します。したがって、funcname は lua_CFunction プロトタイプ（lua_CFunction を参照）に従う必要があります。

これは低レベルの関数です。パッケージおよびモジュールシステムを完全にバイパスします。require とは異なり、パス検索を実行せず、拡張子を自動的に追加しません。libname は、必要に応じてパスと拡張子を含む、C ライブラリの完全なファイル名である必要があります。funcname は、C ライブラリによってエクスポートされた正確な名前である必要があります（これは、使用される C コンパイラーとリンカーによって異なる場合があります）。

この機能は ISO C ではサポートされていません。そのため、一部のプラットフォーム（Windows、Linux、Mac OS X、Solaris、BSD、および dlfcn 標準をサポートするその他の Unix システム）でのみ使用できます。

この関数は本質的に安全ではありません。Lua がシステムの読み取り可能な動的ライブラリ内の任意の関数を呼び出すことができるためです。（Lua は、関数が適切なプロトタイプを持ち、適切なプロトコル（lua_CFunction を参照）を尊重すると仮定して、任意の関数を呼び出します。したがって、任意の動的ライブラリ内の任意の関数を呼び出すと、多くの場合、アクセス違反が発生します。）

package.path

require が Lua ローダーを検索するために使用するパスを含む文字列。

起動時に、Lua は環境変数 LUA_PATH_5_4 または環境変数 LUA_PATH の値、またはこれらの環境変数が定義されていない場合は luaconf.h で定義されたデフォルトのパスを使用して、この変数を初期化します。環境変数の値の ";;" は、デフォルトのパスに置き換えられます。

package.preload

特定のモジュールのローダーを格納するテーブル（require を参照）。

この変数は、実際のテーブルへの参照にすぎません。この変数への代入は、require が使用するテーブルを変更しません。実際のテーブルは、C レジストリ（§4.3 を参照）に格納され、キー LUA_PRELOAD_TABLE（文字列）でインデックス付けされます。

package.searchers

require がモジュールを検索する方法を制御するために使用するテーブル。

このテーブルの各エントリは、検索関数です。モジュールを検索するとき、require はこれらの検索関数を昇順で呼び出し、モジュール名（require に指定された引数）を唯一の引数として指定します。検索機能がモジュールを見つけた場合、モジュールローダーである別の関数と、ローダーに渡され、require によって 2 番目の結果として返される追加の値（ローダーデータ）を返します。モジュールが見つからない場合は、理由を説明する文字列（または何も言うことがない場合は nil）を返します。

Lua は、このテーブルを 4 つの検索関数で初期化します。

最初の検索機能は、package.preload テーブルでローダーを探すだけです。

2 番目の検索機能は、package.path に格納されているパスを使用して、Lua ライブラリとしてローダーを探します。検索は、関数 package.searchpath で説明されているように行われます。

3 番目の検索機能は、変数 package.cpath によって指定されたパスを使用して、C ライブラリとしてローダーを探します。ここでも、検索は関数 package.searchpath で説明されているように行われます。たとえば、C パスが文字列の場合

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

モジュールfooの検索器は、./foo.so、./foo.dll、および/usr/local/foo/init.soの順にファイルを開こうとします。Cライブラリが見つかると、この検索器はまず動的リンク機能を使用してアプリケーションをライブラリにリンクします。次に、ローダーとして使用されるライブラリ内のC関数を見つけようとします。このC関数の名前は、文字列"luaopen_"に、モジュール名のコピーを連結したもので、そのコピーでは、すべてのドットがアンダースコアに置き換えられています。さらに、モジュール名にハイフンが含まれている場合、最初のハイフン以降のサフィックス（ハイフンを含む）は削除されます。たとえば、モジュール名がa.b.c-v2.1の場合、関数名はluaopen_a_b_cになります。

4番目の検索器は、オールインワンローダーを試します。指定されたモジュールのルート名のライブラリをCパスで検索します。たとえば、a.b.cを要求する場合、aのCライブラリを検索します。見つかった場合、サブモジュールのopen関数を検索します。この例では、luaopen_a_b_cになります。この機能を使用すると、パッケージは複数のCサブモジュールを1つのライブラリにまとめることができ、各サブモジュールは元のopen関数を保持します。

最初の検索器（preload）を除くすべての検索器は、package.searchpathによって返されるように、モジュールが見つかったファイルパスを余分な値として返します。最初の検索器は常に文字列":preload:"を返します。

検索器は、Luaでエラーを発生させたり、副作用を持ったりしてはなりません。（Cでは、たとえばアプリケーションをライブラリにリンクするなど、副作用を持つ場合があります。）

package.searchpath (name, path [, sep [, rep]])

指定されたpath内で、指定されたnameを検索します。

パスは、セミコロンで区切られたテンプレートのシーケンスを含む文字列です。各テンプレートについて、関数はテンプレート内の各疑問符（もしあれば）を、nameのコピーで置き換えます。そのコピーでは、sep（デフォルトではドット）のすべての出現箇所がrep（デフォルトではシステムのディレクトリセパレーター）に置き換えられ、結果として得られたファイル名を開こうとします。

たとえば、パスが次の文字列の場合

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

名前foo.aの検索では、ファイル./foo/a.lua、./foo/a.lc、および/usr/local/foo/a/init.luaがこの順に開こうとします。

読み取りモードで開くことができる最初のファイルの結果の名前（ファイルを閉じた後）を返すか、成功しない場合は、failとエラーメッセージを返します。（このエラーメッセージは、開こうとしたすべてのファイル名をリストします。）

6.4 – 文字列操作

このライブラリは、部分文字列の検索や抽出、パターンマッチングなど、文字列操作のための汎用関数を提供します。Luaで文字列をインデックス付けする場合、最初の文字は位置1にあります（Cのように0ではありません）。インデックスは負の値にすることもでき、文字列の末尾から後方に向かってインデックス付けされていると解釈されます。したがって、最後の文字は位置-1にあり、以下同様です。

文字列ライブラリは、テーブルstring内にすべての関数を提供します。また、__indexフィールドがstringテーブルを指す文字列のメタテーブルも設定します。したがって、オブジェクト指向スタイルで文字列関数を使用できます。たとえば、string.byte(s,i)はs:byte(i)と記述できます。

文字列ライブラリは、1バイトの文字エンコードを前提としています。

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

数値コードは、プラットフォーム間で必ずしも移植可能ではありません。

string.char (···)

数値コードは、プラットフォーム間で必ずしも移植可能ではありません。

string.dump (function [, strip])

指定された関数のバイナリ表現（バイナリチャンク）を含む文字列を返します。これにより、この文字列の後のloadは、関数のコピー（ただし、新しいアップ値付き）を返します。stripが真の値である場合、バイナリ表現には、スペースを節約するために、関数に関するすべてのデバッグ情報が含まれない場合があります。

アップ値を持つ関数には、アップ値の数のみが保存されます。ロード（再ロード）されると、これらのアップ値は新しいインスタンスを受け取ります。（これらのアップ値がどのように初期化されるかについての詳細は、load関数を参照してください。デバッグライブラリを使用して、必要に応じて関数のアップ値をシリアル化および再ロードできます。）

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

文字列s内のpattern（§6.4.1を参照）の最初のマッチを検索します。マッチが見つかった場合、findはこの出現の開始と終了のsのインデックスを返します。それ以外の場合は、failを返します。3番目のオプションの数値引数initは、検索を開始する場所を指定します。デフォルト値は1であり、負の値にすることができます。4番目のオプションの引数plainとしてtrueを指定すると、パターンマッチング機能が無効になり、関数はpattern内の文字がマジックと見なされない、プレーンな「部分文字列の検索」操作を実行します。

パターンにキャプチャがある場合、マッチが成功すると、キャプチャされた値も2つのインデックスの後ろに返されます。

string.format (formatstring, ···)

最初の引数（文字列である必要があります）に指定された説明に従って、可変数の引数の書式設定されたバージョンを返します。フォーマット文字列は、ISO C関数sprintfと同じルールに従います。唯一の違いは、変換指定子と修飾子F、n、*、h、L、およびlがサポートされておらず、追加の指定子qがあることです。幅と精度は、存在する場合、どちらも2桁に制限されます。

指定子qは、ブール値、nil、数値、および文字列を、結果がLuaソースコードで有効な定数になるようにフォーマットします。ブール値とnilは、明白な方法（true、false、nil）で記述されます。浮動小数点数は、完全な精度を維持するために16進数で記述されます。文字列は二重引用符で囲まれ、必要に応じてエスケープシーケンスを使用して、Luaインタープリターで安全に読み戻せるようにします。たとえば、呼び出し

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

は、文字列を生成する可能性があります

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

この指定子は、修飾子（フラグ、幅、精度）をサポートしていません。

変換指定子A、a、E、e、f、G、およびgはすべて、引数として数値を予期します。指定子c、d、i、o、u、X、およびxは、整数を予期します。LuaがC89コンパイラーでコンパイルされている場合、指定子Aおよびa（16進浮動小数点）は修飾子をサポートしません。

指定子sは文字列を予期します。引数が文字列でない場合は、tostringの同じルールに従って文字列に変換されます。指定子に修飾子がある場合、対応する文字列引数に埋め込まれたゼロを含めることはできません。

指定子pは、lua_topointerによって返されるポインターを書式設定します。これにより、テーブル、userdata、スレッド、文字列、および関数の一意の文字列識別子が与えられます。他の値（数値、nil、ブール値）の場合、この指定子はポインターNULLを表す文字列になります。

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

例として、次のループは、文字列sのすべての単語を反復処理し、1行に1つずつ出力します。

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

次の例では、指定された文字列からすべての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])

replが文字列の場合、その値は置換に使用されます。文字 %はエスケープ文字として機能します。repl内の%d形式のシーケンス（dは1から9の間）は、d番目のキャプチャされた部分文字列の値を表します。シーケンス%0は、マッチ全体を表します。シーケンス%%は、単一の %を表します。

replがテーブルの場合、テーブルは、最初のキャプチャをキーとして使用して、すべてのマッチに対してクエリされます。

replが関数の場合、この関数は、マッチが発生するたびに、キャプチャされたすべての部分文字列を引数として渡して呼び出されます。

いずれの場合も、パターンがキャプチャを指定しない場合は、パターン全体がキャプチャ内にあるかのように動作します。

テーブルクエリまたは関数呼び出しによって返される値が文字列または数値の場合、置換文字列として使用されます。それ以外の場合、falseまたはnilの場合、置換はありません（つまり、元のマッチは文字列に保持されます）。

以下に例をいくつか示します

     x = string.gsub("hello world", "(%w+)", "%1 %1")
     --> x="hello hello world world"
     
     x = string.gsub("hello world", "%w+", "%0 %0", 1)
     --> x="hello hello world"
     
     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
     --> x="world hello Lua from"
     
     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
     --> x="home = /home/roberto, user = roberto"
     
     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
           return load(s)()
         end)
     --> x="4+5 = 9"
     
     local t = {name="lua", version="5.4"}
     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
     --> x="lua-5.4.tar.gz"

string.len (s)

文字列を受け取り、その長さを返します。空の文字列""の長さは0です。埋め込まれたゼロがカウントされるため、"a\000bc\000"の長さは5です。

string.lower (s)

文字列を受け取り、すべてのuppercaseの文字がlowercaseに変更された、この文字列のコピーを返します。他のすべての文字は変更されません。uppercaseの文字の定義は、現在のロケールに依存します。

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

文字列sの中で、pattern（§6.4.1を参照）に最初にマッチする箇所を探します。マッチするものが見つかった場合、matchはパターンからのキャプチャを返します。それ以外の場合はfailを返します。patternがキャプチャを指定しない場合は、マッチ全体が返されます。3番目のオプションの数値引数initは、検索を開始する位置を指定します。デフォルト値は1で、負の値も指定できます。

string.pack (fmt, v1, v2, ···)

フォーマット文字列fmt（§6.4.2を参照）に従って、バイナリ形式でシリアライズ（パック）された値v1、v2などを含むバイナリ文字列を返します。

string.packsize (fmt)

string.packを、与えられたフォーマットで実行した場合の結果の文字列の長さを返します。フォーマット文字列は、可変長オプションである's'または'z'を持つことはできません（§6.4.2を参照）。

string.rep (s, n [, sep])

文字列sをn回コピーし、文字列sepで区切って連結した文字列を返します。sepのデフォルト値は空文字列です（つまり、区切り文字なし）。nが正でない場合は、空文字列を返します。

（この関数を1回呼び出すだけで、マシンのメモリを使い果たしてしまう可能性があることに注意してください。）

string.reverse (s)

文字列sを反転させた文字列を返します。

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

iから始まりjまで続く、sの部分文字列を返します。iとjは負の値を取ることができます。jが省略された場合、-1（文字列の長さと同じ）とみなされます。特に、string.sub(s,1,j)の呼び出しは、長さjのsの接頭辞を返し、string.sub(s, -i)（正のiの場合）は、長さiのsの接尾辞を返します。

負のインデックスの変換後、iが1未満の場合は1に修正されます。jが文字列の長さよりも大きい場合は、文字列の長さに修正されます。これらの修正後、iがjよりも大きい場合、関数は空文字列を返します。

string.unpack (fmt, s [, pos])

フォーマット文字列fmt（§6.4.2を参照）に従って、文字列sにパックされた値（string.packを参照）を返します。オプションのposは、sの読み取りを開始する位置を示します（デフォルトは1）。読み取られた値の後、この関数はs内で最初に読み取られていないバイトのインデックスも返します。

string.upper (s)

文字列を受け取り、この文字列のすべての小文字を大文字に変更したコピーを返します。他のすべての文字は変更されません。小文字の定義は、現在のロケールによって異なります。

6.4.1 – パターン

Luaのパターンは、正規の文字列で記述され、パターンマッチング関数であるstring.find、string.gmatch、string.gsub、およびstring.matchによってパターンとして解釈されます。このセクションでは、これらの文字列の構文と意味（つまり、何にマッチするか）について説明します。

文字クラス

文字クラスは、文字の集合を表すために使用されます。文字クラスを記述する際には、以下の組み合わせが許可されています。

• x: （xがマジック文字である^$()%.[]*+-?のいずれでもない場合）文字x自体を表します。
• .: （ドット）はすべての文字を表します。
• %a: はすべてのアルファベット文字を表します。
• %c: はすべての制御文字を表します。
• %d: はすべての数字を表します。
• %g: はスペースを除くすべての印刷可能な文字を表します。
• %l: はすべての小文字を表します。
• %p: はすべての句読点を表します。
• %s: はすべての空白文字を表します。
• %u: はすべての大文字を表します。
• %w: はすべての英数字を表します。
• %x: はすべての16進数を表します。
• %x: （xが任意の非英数字の場合）文字xを表します。これは、マジック文字をエスケープする標準的な方法です。任意の非英数字（すべての句読点文字、さらには非マジック文字も含む）の前に '%' を付けて、パターン内でそれ自体を表すことができます。
• [set]: は、set内のすべての文字の和集合であるクラスを表します。文字の範囲は、範囲の終端文字を昇順で '-' で区切って指定できます。上記で説明したすべてのクラス%xも、set内のコンポーネントとして使用できます。set内の他のすべての文字は、それ自体を表します。たとえば、[%w_]（または[_%w]）はすべての英数字とアンダースコアを表し、[0-7]は8進数を表し、[0-7%l%-]は8進数と小文字と '-' 文字を表します。

  セット内に閉じ角括弧を配置するには、セット内の最初の文字として配置します。セット内にハイフンを配置するには、セット内の最初または最後の文字として配置します。（両方の場合にエスケープを使用することもできます。）

  範囲とクラスの間の相互作用は定義されていません。したがって、[%a-z]や[a-%%]のようなパターンには意味がありません。

• [^set]: は、setの補数を表します。ここで、setは上記のように解釈されます。

単一の文字で表されるすべてのクラス（%a、%cなど）の場合、対応する大文字はクラスの補数を表します。たとえば、%Sは空白以外のすべての文字を表します。

文字、スペース、その他の文字グループの定義は、現在のロケールによって異なります。特に、クラス[a-z]は%lと等価ではない場合があります。

パターン項目

パターン項目は次のいずれかです。

• 単一の文字クラス。クラス内の任意の単一の文字にマッチします。
• 単一の文字クラスの後に '*' が続く場合。クラス内のゼロ個以上の文字のシーケンスにマッチします。これらの繰り返し項目は、常に可能な限り最長のシーケンスにマッチします。
• 単一の文字クラスの後に '+' が続く場合。クラス内の1つ以上の文字のシーケンスにマッチします。これらの繰り返し項目は、常に可能な限り最長のシーケンスにマッチします。
• 単一の文字クラスの後に '-' が続く場合。これも、クラス内のゼロ個以上の文字のシーケンスにマッチします。 '*' とは異なり、これらの繰り返し項目は、常に可能な限り最短のシーケンスにマッチします。
• 単一の文字クラスの後に '?' が続く場合。クラス内の文字のゼロ個または1個の出現にマッチします。可能な場合は常に1つの出現にマッチします。
• %n（nは1から9の間）。このような項目は、n番目のキャプチャされた文字列と等しい部分文字列にマッチします（以下を参照）。
• %bxy。ここで、xとyは2つの異なる文字です。このような項目は、xで始まり、yで終わり、xとyがバランスしている文字列にマッチします。これは、文字列を左から右に読み、xの場合は+1、yの場合は-1を数えた場合、最後のyはカウントが0に達する最初のyであることを意味します。たとえば、項目%b()は、バランスの取れた括弧を持つ式にマッチします。
• %f[set]。フロンティアパターンです。このような項目は、次の文字がsetに属し、前の文字がsetに属さないような任意の場所にある空文字列にマッチします。セットsetは、上記のように解釈されます。サブジェクトの先頭と末尾は、文字 '\0' であるかのように処理されます。

パターン

パターンは、パターン項目のシーケンスです。パターンの先頭にあるキャレット '^' は、マッチをサブジェクト文字列の先頭に固定します。パターンの末尾にある '$' は、マッチをサブジェクト文字列の末尾に固定します。他の位置では、'^' と '$' は特別な意味を持たず、それ自身を表します。

キャプチャ

パターンには、括弧で囲まれたサブパターンを含めることができます。これらはキャプチャを記述します。マッチが成功すると、キャプチャにマッチするサブジェクト文字列の部分文字列が、後で使用するために保存（キャプチャ）されます。キャプチャは、左括弧に従って番号が付けられます。たとえば、パターン"(a*(.)%w(%s*))"では、"a*(.)%w(%s*)"にマッチする文字列の部分が最初のキャプチャとして保存されるため、番号は1になります。 "."にマッチする文字は番号2でキャプチャされ、"%s*"にマッチする部分は番号3でキャプチャされます。

特別なケースとして、キャプチャ()は現在の文字列位置（数値）をキャプチャします。たとえば、文字列"flaaap"にパターン"()aa()"を適用した場合、2つのキャプチャ（3と5）が得られます。

複数マッチ

関数string.gsubとイテレータstring.gmatchは、サブジェクト内の指定されたパターンの複数の出現箇所にマッチします。これらの関数では、新しいマッチは、前のマッチの終了位置よりも少なくとも1バイト後で終了する場合にのみ有効と見なされます。言い換えれば、パターンマシンは、別のマッチの直後に空文字列をマッチとして受け入れることはありません。例として、次のコードの結果を考えてみましょう。

     > string.gsub("abc", "()a*()", print);
     --> 1   2
     --> 3   3
     --> 4   4

2番目と3番目の結果は、Luaが 'b' の後と 'c' の後で空文字列にマッチしたことによるものです。Luaは 'a' の後に空文字列をマッチさせません。なぜなら、それは前のマッチと同じ位置で終了するためです。

6.4.2 – PackおよびUnpackのフォーマット文字列

string.pack、string.packsize、およびstring.unpackの最初の引数はフォーマット文字列であり、作成または読み取られる構造のレイアウトを記述します。

フォーマット文字列は、変換オプションのシーケンスです。変換オプションは次のとおりです。

• <: リトルエンディアンを設定します
• >: ビッグエンディアンを設定します
• =: ネイティブエンディアンを設定します
• ![n]: 最大アライメントをnに設定します（デフォルトはネイティブアライメント）
• b: 符号付きバイト（char）
• B: 符号なしバイト（char）
• h: 符号付きshort（ネイティブサイズ）
• H: 符号なしshort（ネイティブサイズ）
• l: 符号付きlong（ネイティブサイズ）
• L: 符号なしlong（ネイティブサイズ）
• j: lua_Integer
• J: lua_Unsigned
• T: size_t（ネイティブサイズ）
• i[n]: nバイトの符号付きint（デフォルトはネイティブサイズ）
• I[n]: nバイトの符号なしint（デフォルトはネイティブサイズ）
• f: float（ネイティブサイズ）
• d: double（ネイティブサイズ）
• n: lua_Number
• cn: nバイトの固定長文字列
• z: ゼロ終端文字列
• s[n]: 長さがnバイトの符号なし整数としてコード化された長さが前に付いた文字列（デフォルトはsize_t）
• x: 1バイトのパディング
• Xop: オプションopに従ってアライメントする空の項目（それ以外の場合は無視されます）
• ' ': （スペース）無視されます

（"[n]" はオプションの整数を意味します。）パディング、スペース、および構成（オプション"xX <=>!"）を除き、各オプションは、string.packの引数またはstring.unpackの結果に対応します。

オプション "!n", "sn", "in", および "In" では、n は 1 から 16 までの任意の整数です。すべての整数オプションはオーバーフローをチェックします。 string.pack は、指定された値が指定されたサイズに収まるかどうかをチェックし、string.unpack は、読み取った値が Lua 整数に収まるかどうかをチェックします。符号なしオプションの場合、Lua 整数も符号なしの値として扱われます。

任意のフォーマット文字列は、"!1=" が前に付いているかのように開始します。つまり、最大アライメントが 1（アライメントなし）で、ネイティブエンディアンで開始します。

ネイティブエンディアンは、システム全体がビッグエンディアンまたはリトルエンディアンのいずれかであると想定します。パッキング関数は、混合エンディアンフォーマットの動作を正しくエミュレートしません。

アライメントは次のように機能します。各オプションについて、フォーマットは、データの開始オフセットがオプションサイズと最大アライメントの最小値の倍数になるまで、追加のパディングを取得します。この最小値は 2 のべき乗である必要があります。オプション "c" および "z" はアラインされません。オプション "s" は、開始整数のアライメントに従います。

すべてのパディングは、string.pack によってゼロで埋められ、string.unpack によって無視されます。

6.5 – UTF-8 サポート

このライブラリは、UTF-8 エンコーディングの基本的なサポートを提供します。このライブラリは、すべての関数を utf8 テーブル内に提供します。このライブラリは、エンコーディングの処理以外に、Unicode のサポートを提供しません。文字分類など、文字の意味を必要とする操作は、その範囲外です。

特に明記しない限り、バイト位置をパラメータとして期待するすべての関数は、指定された位置がバイトシーケンスの開始であるか、サブジェクト文字列の長さプラス 1 であると想定します。文字列ライブラリと同様に、負のインデックスは文字列の末尾から数えます。

バイトシーケンスを作成する関数は、元の UTF-8 仕様で定義されているように、0x7FFFFFFF までのすべての値を受け入れます。これは、最大 6 バイトまでのバイトシーケンスを意味します。

バイトシーケンスを解釈する関数は、有効なシーケンス（整形式であり、過長でない）のみを受け入れます。デフォルトでは、10FFFF より大きい値とサロゲートを拒否し、有効な Unicode コードポイントになるバイトシーケンスのみを受け入れます。ブール値引数 lax が使用可能な場合、これらのチェックを解除し、0x7FFFFFFF までのすべての値を受け入れるようにします。（整形式でないシーケンスと過長なシーケンスは引き続き拒否されます。）

utf8.char (···)

0 個以上の整数を受け取り、それぞれを対応する UTF-8 バイトシーケンスに変換し、これらのシーケンスすべてを連結した文字列を返します。

utf8.charpattern

パターン（関数ではなく文字列） "[\0-\x7F\xC2-\xFD][\x80-\xBF]*"（§6.4.1を参照）は、サブジェクトが有効な UTF-8 文字列であると仮定して、正確に 1 つの UTF-8 バイトシーケンスに一致します。

utf8.codes (s [, lax])

次の構成で、

     for p, c in utf8.codes(s) do body end

文字列 s 内のすべての UTF-8 文字を反復処理し、p が位置（バイト単位）であり、c が各文字のコードポイントとなるように値を返します。無効なバイトシーケンスが見つかった場合はエラーが発生します。

utf8.codepoint (s [, i [, j [, lax]]])

バイト位置 i と j の間（両方を含む）で開始される、s 内のすべての文字のコードポイント（整数として）を返します。i のデフォルトは 1 で、j のデフォルトは i です。無効なバイトシーケンスが見つかった場合はエラーが発生します。

utf8.len (s [, i [, j [, lax]]])

位置 i と j の間（両方を含む）で開始される文字列 s 内の UTF-8 文字の数を返します。i のデフォルトは 1 で、j のデフォルトは -1 です。無効なバイトシーケンスが見つかった場合は、fail と最初の無効なバイトの位置を返します。

utf8.offset (s, n [, i])

s の n 番目の文字（位置 i から数える）のエンコーディングが開始する位置（バイト単位）を返します。負の n は、位置 i より前の文字を取得します。n が非負の場合、i のデフォルトは 1 であり、それ以外の場合は #s + 1 であるため、utf8.offset(s, -n) は文字列の末尾から n 番目の文字のオフセットを取得します。指定された文字がサブジェクト内にもその直後にもない場合、関数は fail を返します。

特別なケースとして、n が 0 の場合、関数は s の i 番目のバイトを含む文字のエンコーディングの開始を返します。

この関数は、s が有効な UTF-8 文字列であることを前提としています。

6.6 – テーブル操作

このライブラリは、テーブル操作のための汎用関数を提供します。このライブラリは、すべての関数を table テーブル内に提供します。

操作でテーブルの長さが必要な場合は常に、長さ演算子に関するすべての注意が適用されることに注意してください（§3.4.7を参照）。すべての関数は、引数として指定されたテーブル内の数値以外のキーを無視します。

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

すべての要素が文字列または数値であるリストが与えられた場合、文字列 list[i]..sep..list[i+1] ··· sep..list[j] を返します。sep のデフォルト値は空文字列で、i のデフォルトは 1 で、j のデフォルトは #list です。i が j より大きい場合は、空文字列を返します。

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

list の位置 pos に要素 value を挿入し、要素 list[pos], list[pos+1], ···, list[#list] を上にシフトします。pos のデフォルト値は #list+1 であるため、table.insert(t,x) を呼び出すと、x がリスト t の末尾に挿入されます。

table.move (a1, f, e, t [,a2])

テーブル a1 からテーブル a2 に要素を移動し、次の多重代入と同等の処理を実行します: a2[t],··· = a1[f],···,a1[e]。a2 のデフォルトは a1 です。移動先範囲は、移動元範囲と重複する可能性があります。移動する要素の数は、Lua 整数に収まる必要があります。

移動先テーブル a2 を返します。

table.pack (···)

すべての引数をキー 1、2 などに格納し、引数の総数を持つフィールド "n" を含む新しいテーブルを返します。一部の引数が nil の場合、結果のテーブルがシーケンスではない場合があることに注意してください。

table.remove (list [, pos])

list から位置 pos の要素を削除し、削除された要素の値を返します。pos が 1 から #list の間の整数である場合、要素 list[pos+1], list[pos+2], ···, list[#list] を下にシフトし、要素 list[#list] を消去します。インデックス pos は、#list が 0 の場合は 0 にすることも、#list + 1 にすることもできます。

pos のデフォルト値は #list であるため、table.remove(l) を呼び出すと、リスト l の最後の要素が削除されます。

table.sort (list [, comp])

リスト要素を指定された順序で、インプレース で list[1] から list[#list] までソートします。comp が指定されている場合は、2 つのリスト要素を受け取り、最終的な順序で最初の要素が 2 番目の要素の前に来る必要がある場合に true を返す関数である必要があります。したがって、ソート後、i <= j は not comp(list[j],list[i]) を意味します。comp が指定されていない場合は、代わりに標準の Lua 演算子 < が使用されます。

comp 関数は、一貫した順序を定義する必要があります。より正式には、関数は厳密な弱順序を定義する必要があります。（弱順序は全順序に似ていますが、比較目的で異なる要素を同等に扱うことができます。）

ソートアルゴリズムは安定していません。指定された順序で等しいと見なされる異なる要素は、ソートによって相対位置が変更される可能性があります。

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

指定されたリストから要素を返します。この関数は、次と同等です。

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

デフォルトでは、i は 1 で、j は #list です。

6.7 – 数学関数

このライブラリは、基本的な数学関数を提供します。このライブラリは、すべての関数と定数を math テーブル内に提供します。「integer/float」の注釈が付いた関数は、整数引数に対しては整数結果を、非整数引数に対しては浮動小数点結果を返します。丸め関数 math.ceil、math.floor、および math.modf は、結果が整数の範囲に収まる場合は整数を、それ以外の場合は浮動小数点数を返します。

math.abs (x)

x と -x の間の最大値を返します。（整数/浮動小数点）

math.acos (x)

x の逆コサイン（ラジアン単位）を返します。

math.asin (x)

x の逆サイン（ラジアン単位）を返します。

math.atan (y [, x])

y/x の逆タンジェント（ラジアン単位）を、両方の引数の符号を使用して結果の象限を求めながら返します。x がゼロの場合も正しく処理します。

x のデフォルト値は 1 であるため、math.atan(y) を呼び出すと y の逆タンジェントが返されます。

math.ceil (x)

x 以上の最小の整数値を返します。

math.cos (x)

x のコサイン（ラジアン単位であると仮定）を返します。

math.deg (x)

角度 x をラジアンから度に変換します。

math.exp (x)

値 e^x を返します（ここで、e は自然対数の底です）。

math.floor (x)

x 以下の最大の整数値を返します。

math.fmod (x, y)

商をゼロに向かって丸める、x を y で割った余りを返します。（整数/浮動小数点）

math.huge

浮動小数点値 HUGE_VAL。他の任意の数値よりも大きい値です。

math.log (x [, base])

指定された底での x の対数を返します。base のデフォルトは e です（したがって、関数は x の自然対数を返します）。

math.max (x, ···)

Lua 演算子 < に従って、最大値を持つ引数を返します。

math.maxinteger

math.min (x, ···)

Luaの演算子<に従って、最小値を持つ引数を返します。

math.mininteger

math.modf (x)

xの整数部分と小数部分を返します。2番目の結果は常に浮動小数点数です。

math.pi

πの値。

math.rad (x)

角度xを度からラジアンに変換します。

math.random ([m [, n]])

引数なしで呼び出された場合、範囲[0,1)で一様分布する擬似乱数浮動小数点数を返します。2つの整数mとnで呼び出された場合、math.randomは範囲[m, n]で一様分布する擬似乱数整数を返します。正のnに対する呼び出しmath.random(n)は、math.random(1,n)と同等です。呼び出しmath.random(0)は、すべてのビットが（擬似）ランダムな整数を生成します。

この関数は、擬似乱数64ビット整数を生成するためにxoshiro256**アルゴリズムを使用します。これらは、引数0で呼び出した結果です。他の結果（範囲と浮動小数点数）は、これらの整数から偏りなく抽出されます。

Luaは、math.randomseedを引数なしで呼び出した場合と同様の方法で擬似乱数ジェネレーターを初期化するため、math.randomはプログラムが実行されるたびに異なる結果のシーケンスを生成する必要があります。

math.randomseed ([x [, y]])

少なくとも1つの引数で呼び出された場合、整数パラメータxとyは、擬似乱数ジェネレーターを再初期化するために使用される128ビットのシードに結合されます。等しいシードは、等しい数のシーケンスを生成します。yのデフォルトはゼロです。

引数なしで呼び出された場合、Luaはランダム化を弱く試みたシードを生成します。

この関数は、実際に使用された2つのシードコンポーネントを返すため、それらを再度設定するとシーケンスが繰り返されます。

初期状態に必要なレベルのランダム性を確保するため（または逆に、たとえばプログラムのデバッグ時に決定的なシーケンスを持たせるため）、明示的な引数を使用してmath.randomseedを呼び出す必要があります。

math.sin (x)

xのサイン（ラジアン単位とみなされます）を返します。

math.sqrt (x)

xの平方根を返します。（この値を計算するには、式x^0.5を使用することもできます。）

math.tan (x)

xのタンジェント（ラジアン単位とみなされます）を返します。

math.tointeger (x)

値xが整数に変換可能な場合、その整数を返します。それ以外の場合は、failを返します。

math.type (x)

xが整数の場合は "integer"、浮動小数点数の場合は "float"、xが数値でない場合はfailを返します。

math.ult (m, n)

整数mが符号なし整数として比較されたときに整数nより小さい場合に限り、ブール値trueを返します。

6.8 – 入出力機能

I/Oライブラリは、ファイル操作に2つの異なるスタイルを提供します。最初のスタイルは暗黙的なファイルハンドルを使用します。つまり、デフォルトの入力ファイルとデフォルトの出力ファイルを設定する操作があり、すべての入出力操作はこれらのデフォルトファイルに対して行われます。2番目のスタイルは明示的なファイルハンドルを使用します。

暗黙的なファイルハンドルを使用する場合、すべての操作はテーブルioによって提供されます。明示的なファイルハンドルを使用する場合、操作io.openはファイルハンドルを返し、すべての操作はファイルハンドルのメソッドとして提供されます。

ファイルハンドルのメタテーブルは、呼び出されたときにファイルを閉じようとする__gcと__closeのメタメソッドを提供します。

テーブルioは、Cからの通常の意味を持つ3つの定義済みのファイルハンドルも提供します。io.stdin、io.stdout、およびio.stderr。I/Oライブラリはこれらのファイルを閉じることはありません。

特に明記されていない限り、すべてのI/O関数は失敗した場合にfailを返し、さらに2番目の結果としてエラーメッセージ、3番目の結果としてシステム依存のエラーコード、成功した場合はfalse以外の値を返します。非POSIXシステムでは、エラーの場合のエラーメッセージとエラーコードの計算は、グローバルC変数errnoに依存するため、スレッドセーフでない場合があります。

io.close ([file])

file:close()と同等です。fileがない場合は、デフォルトの出力ファイルを閉じます。

io.flush ()

io.output():flush()と同等です。

io.input ([file])

ファイル名で呼び出された場合、指定されたファイル（テキストモード）を開き、そのハンドルをデフォルトの入力ファイルとして設定します。ファイルハンドルで呼び出された場合、このファイルハンドルをデフォルトの入力ファイルとして設定します。引数なしで呼び出された場合、現在のデフォルトの入力ファイルを返します。

エラーの場合、この関数はエラーコードを返すのではなく、エラーを発生させます。

io.lines ([filename, ···])

指定されたファイル名を読み取りモードで開き、開いたファイルに対してfile:lines(···)のように機能するイテレータ関数を返します。イテレータ関数が値を読み取ることができなかった場合、自動的にファイルを閉じます。イテレータ関数に加えて、io.linesは他の3つの値を返します。プレースホルダーとして2つのnil値、プラス作成されたファイルハンドルです。したがって、ジェネリックforループで使用する場合、ループがエラーまたはbreakによって中断された場合でも、ファイルは閉じられます。

呼び出しio.lines()（ファイル名なし）はio.input():lines("l")と同等です。つまり、デフォルトの入力ファイルの行を反復処理します。この場合、イテレータはループが終了してもファイルを閉じません。

ファイルを開く際のエラーの場合、この関数はエラーコードを返すのではなく、エラーを発生させます。

io.open (filename [, mode])

この関数は、文字列modeで指定されたモードでファイルを開きます。成功した場合、新しいファイルハンドルを返します。

mode文字列は、次のいずれかになります。

• "r": 読み取りモード（デフォルト）;
• "w": 書き込みモード;
• "a": 追加モード;
• "r+": 更新モード、以前のすべてのデータは保持されます;
• "w+": 更新モード、以前のすべてのデータは消去されます;
• "a+": 追加更新モード、以前のデータは保持され、書き込みはファイルの最後にのみ許可されます。

mode文字列の末尾には'b'を含めることもできます。これは、一部のシステムでファイルをバイナリモードで開くために必要です。

io.output ([file])

io.inputと同様ですが、デフォルトの出力ファイルに対して動作します。

io.popen (prog [, mode])

この関数はシステムに依存し、すべてのプラットフォームで使用できるわけではありません。

別のプロセスでプログラムprogを開始し、このプログラムからデータを読み取る（modeが"r"の場合、デフォルト）か、このプログラムにデータを書き込む（modeが"w"の場合）ために使用できるファイルハンドルを返します。

io.read (···)

io.input():read(···)と同等です。

io.tmpfile ()

成功した場合、一時ファイルのハンドルを返します。このファイルは更新モードで開かれ、プログラムが終了すると自動的に削除されます。

io.type (obj)

objが有効なファイルハンドルであるかどうかを確認します。objが開いているファイルハンドルの場合は文字列"file"、objが閉じているファイルハンドルの場合は"closed file"、objがファイルハンドルではない場合はfailを返します。

io.write (···)

io.output():write(···)と同等です。

file:close ()

fileを閉じます。ファイルはハンドルがガベージコレクションされると自動的に閉じられますが、それには予測できない時間がかかることに注意してください。

io.popenで作成されたファイルハンドルを閉じると、file:closeはos.executeによって返された同じ値を返します。

file:flush ()

fileに書き込まれたデータを保存します。

file:lines (···)

呼び出されるたびに、指定された形式に従ってファイルを読み取るイテレータ関数を返します。形式が指定されていない場合は、デフォルトとして "l" を使用します。例として、次の構文は

     for c in file:lines(1) do body end

現在の位置から始まるファイルのすべての文字を反復処理します。io.linesとは異なり、この関数はループが終了してもファイルを閉じません。

file:read (···)

何を読み取るかを指定する指定された形式に従って、ファイルfileを読み取ります。形式ごとに、関数は読み取られた文字の文字列または数値を返すか、指定された形式でデータを読み取ることができない場合はfailを返します。（後者の場合、関数は後続の形式を読み取りません。）引数なしで呼び出された場合、次の行を読み取るデフォルトの形式を使用します（以下を参照）。

使用可能な形式は次のとおりです。

• "n": 数値を読み取り、Luaの字句規則に従って浮動小数点数または整数として返します。（数値には、先頭の空白と符号を含めることができます。）この形式は、常に数値の有効なプレフィックスである最長の入力シーケンスを読み取ります。そのプレフィックスが有効な数値を形成しない場合（たとえば、空の文字列、"0x"、または "3.4e-"）、または長すぎる場合（200文字を超える）、破棄され、形式はfailを返します。
• "a": 現在の位置から始まるファイル全体を読み取ります。ファイルの終わりに、空の文字列を返します。この形式は失敗しません。
• "l": 次の行を読み取り、行末をスキップし、ファイルの終わりにfailを返します。これはデフォルトの形式です。
• "L": 行末文字（存在する場合）を保持したまま、次の行を読み取り、ファイルの終わりにfailを返します。
• number: 最大でこのバイト数の文字列を読み取り、ファイルの終わりにfailを返します。numberがゼロの場合、何も読み取らず、空の文字列を返すか、ファイルの終わりにfailを返します。

形式"l"と"L"はテキストファイルに対してのみ使用する必要があります。

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

ファイルの先頭からのファイル位置を、文字列whenceで指定されたベースにoffsetを加えた位置に設定および取得します。以下のように

• "set": ベースは位置0（ファイルの先頭）です。
• "cur": ベースは現在の位置です。
• "end": ベースはファイルの末尾です。

成功した場合、seekは、ファイルの先頭からバイト単位で測定された最終的なファイル位置を返します。seekが失敗した場合、failとエラーを説明する文字列を返します。

whenceのデフォルト値は"cur"で、offsetのデフォルト値は0です。したがって、呼び出しfile:seek()は、現在のファイル位置を返しますが、変更はしません。呼び出しfile:seek("set")は、位置をファイルの先頭に設定し（0を返します）。呼び出しfile:seek("end")は、位置をファイルの末尾に設定し、そのサイズを返します。

file:setvbuf (mode [, size])

ファイルに対するバッファリングモードを設定します。3つのモードが利用可能です。

• "no": バッファリングなし。
• "full": フルバッファリング。
• "line": 行バッファリング。

最後の2つのケースでは、sizeはバッファのサイズ（バイト単位）のヒントです。デフォルトは適切なサイズです。

各モードの具体的な動作は移植性がないため、詳細についてはプラットフォームの基盤となるISO C関数setvbufを確認してください。

file:write (···)

引数のそれぞれの値をfileに書き込みます。引数は文字列または数値である必要があります。

成功した場合、この関数はfileを返します。

6.9 – オペレーティングシステム機能

このライブラリは、テーブルosを通して実装されています。

os.clock ()

プログラムが使用したCPU時間の概算（秒単位）を、基盤となるISO C関数clockによって返される値として返します。

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

指定された文字列formatに従ってフォーマットされた、日付と時間を含む文字列またはテーブルを返します。

time引数が存在する場合、これはフォーマットされる時間です（この値の説明についてはos.time関数を参照してください）。それ以外の場合、dateは現在の時間をフォーマットします。

formatが'!'で始まる場合、日付は協定世界時でフォーマットされます。このオプションの文字の後、formatが文字列"*t"の場合、dateは次のフィールドを持つテーブルを返します：year、month（1–12）、day（1–31）、hour（0–23）、min（0–59）、sec（うるう秒のため0–61）、wday（曜日、1–7、日曜日は1）、yday（年の日数、1–366）、およびisdst（夏時間フラグ、ブール値）。この最後のフィールドは、情報が利用できない場合は存在しない可能性があります。

formatが"*t"でない場合、dateはISO C関数strftimeと同じルールに従ってフォーマットされた日付を文字列として返します。

formatがない場合、デフォルトは"%c"になり、これは現在のロケールを使用して人間が読める日付と時刻の表現を提供します。

非POSIXシステムでは、この関数はC 関数gmtimeおよびC 関数localtimeに依存しているため、スレッドセーフでない場合があります。

os.difftime (t2, t1)

時間t1から時間t2までの差（秒単位）を返します（ここで、時間はos.timeによって返される値です）。POSIX、Windows、および他のいくつかのシステムでは、この値は正確にt2-t1です。

os.execute ([command])

この関数は、ISO C関数systemと同等です。オペレーティングシステムのシェルによって実行されるようにcommandを渡します。その最初の結果は、コマンドが正常に終了した場合はtrue、それ以外の場合はfailです。この最初の結果の後、関数は以下のように、文字列と数値を返します。

• "exit": コマンドが正常に終了しました。次の数値は、コマンドの終了ステータスです。
• "signal": コマンドがシグナルによって終了しました。次の数値は、コマンドを終了したシグナルです。

commandなしで呼び出された場合、os.executeはシェルが利用可能な場合はtrueであるブール値を返します。

os.exit ([code [, close]])

ホストプログラムを終了するためにISO C関数exitを呼び出します。codeがtrueの場合、返されるステータスはEXIT_SUCCESSです。codeがfalseの場合、返されるステータスはEXIT_FAILUREです。codeが数値の場合、返されるステータスはこの数値です。codeのデフォルト値はtrueです。

オプションの2番目の引数closeがtrueの場合、関数は終了する前にLua状態を閉じます（lua_closeを参照）。

os.getenv (varname)

プロセス環境変数varnameの値を返します。変数定義されていない場合はfailを返します。

os.remove (filename)

指定された名前のファイル（またはPOSIXシステム上の空のディレクトリ）を削除します。この関数が失敗した場合、failに加えて、エラーとエラーコードを説明する文字列を返します。それ以外の場合は、trueを返します。

os.rename (oldname, newname)

oldnameという名前のファイルまたはディレクトリをnewnameに名前変更します。この関数が失敗した場合、failに加えて、エラーとエラーコードを説明する文字列を返します。それ以外の場合は、trueを返します。

os.setlocale (locale [, category])

プログラムの現在のロケールを設定します。localeはロケールを指定するシステム依存の文字列です。categoryは変更するカテゴリを説明するオプションの文字列です："all"、"collate"、"ctype"、"monetary"、"numeric"、または"time"。デフォルトのカテゴリは"all"です。この関数は新しいロケールの名前を返します。リクエストが受け入れられない場合はfailを返します。

localeが空の文字列の場合、現在のロケールは実装定義のネイティブロケールに設定されます。localeが文字列"C"の場合、現在のロケールは標準Cロケールに設定されます。

最初の引数としてnilを付けて呼び出された場合、この関数は指定されたカテゴリの現在のロケールの名前のみを返します。

この関数は、C 関数setlocaleに依存しているため、スレッドセーフでない場合があります。

os.time ([table])

引数なしで呼び出された場合は現在の時刻を返します。または、指定されたテーブルで指定されたローカルの日時を表す時刻を返します。このテーブルには、フィールドyear、month、およびdayが必要であり、フィールドhour（デフォルトは12）、min（デフォルトは0）、sec（デフォルトは0）、およびisdst（デフォルトはnil）を持つことができます。他のフィールドは無視されます。これらのフィールドの説明については、os.date関数を参照してください。

関数が呼び出されると、これらのフィールドの値が有効な範囲内にある必要はありません。たとえば、secが-10の場合、他のフィールドで指定された時間の10秒前を意味します。hourが1000の場合、他のフィールドで指定された時間の1000時間後を意味します。

返される値は数値であり、その意味はシステムによって異なります。POSIX、Windows、およびその他のいくつかのシステムでは、この数値はある特定の開始時間（「エポック」）からの秒数をカウントします。他のシステムでは、意味は指定されておらず、timeによって返される数値は、os.dateおよびos.difftimeへの引数としてのみ使用できます。

テーブルで呼び出された場合、os.timeはos.date関数でドキュメント化されているすべてのフィールドも正規化するため、呼び出し前と同じ時刻を表しますが、値は有効な範囲内になります。

os.tmpname ()

一時ファイルに使用できるファイル名を持つ文字列を返します。ファイルは、使用する前に明示的に開き、不要になったら明示的に削除する必要があります。

POSIXシステムでは、この関数はセキュリティリスクを回避するために、その名前のファイルも作成します。（名前を取得してからファイルを作成するまでの間に、別の誰かが間違った権限でファイルを作成する可能性があります。）ファイルを使用するためにファイルを開き、削除する必要があるのは変わりません（たとえ使用しなくても）。

可能であれば、プログラムが終了したときにファイルを自動的に削除するio.tmpfileを使用することをお勧めします。

6.10 – デバッグライブラリ

このライブラリは、Luaプログラムへのデバッグインターフェイス（§4.7）の機能を提供します。このライブラリを使用するときは注意が必要です。そのいくつかの関数は、Luaコードに関する基本的な仮定（たとえば、関数のローカル変数は外部からアクセスできないこと、userdataメタテーブルはLuaコードで変更できないこと、Luaプログラムはクラッシュしないこと）に違反するため、そうでない場合は安全なコードを危険にさらす可能性があります。さらに、このライブラリの一部の関数は遅くなる可能性があります。

このライブラリのすべての関数は、debugテーブル内に提供されています。スレッドを操作するすべての関数には、操作するスレッドであるオプションの最初の引数があります。デフォルトは常に現在のスレッドです。

debug.debug ()

ユーザーが入力した各文字列を実行して、ユーザーとの対話モードに入ります。単純なコマンドやその他のデバッグ機能を使用して、ユーザーはグローバル変数とローカル変数を検査したり、それらの値を変更したり、式を評価したりできます。単語contのみを含む行は、この関数を終了させ、呼び出し元が実行を継続できるようにします。

debug.debugのコマンドは、どの関数にも字句的にネストされていないため、ローカル変数に直接アクセスできないことに注意してください。

debug.gethook ([thread])

スレッドの現在のフック設定を、3つの値として返します：現在のフック関数、現在のフックマスク、およびdebug.sethook関数によって設定された現在のフックカウント。

アクティブなフックがない場合はfailを返します。

debug.getinfo ([thread,] f [, what])

関数に関する情報を含むテーブルを返します。関数を直接指定することも、fの値として数値を指定することもできます。これは、指定されたスレッドの呼び出しスタックのレベルfで実行されている関数を意味します：レベル0は現在の関数（getinfo自体）です。レベル1はgetinfoを呼び出した関数です（スタックにカウントされない末尾呼び出しを除く）。以下同様です。fがアクティブな関数の数よりも大きい数値の場合、getinfoはfailを返します。

返されるテーブルには、lua_getinfoによって返されるすべてのフィールドを含めることができ、どのフィールドに入力するかを記述する文字列whatを含めることができます。whatのデフォルトは、有効な行のテーブルを除く、利用可能なすべての情報を取得することです。存在する場合、オプション「f」は、関数自体を持つfuncという名前のフィールドを追加します。存在する場合、オプション「L」は、有効な行のテーブルを持つactivelinesという名前のフィールドを追加します。

たとえば、式debug.getinfo(1,"n").nameは、合理的な名前が見つかる場合は、現在の関数の名前を返し、式debug.getinfo(print)は、print関数に関するすべての利用可能な情報を含むテーブルを返します。

debug.getlocal ([thread,] f, local)

この関数は、スタックのレベルfの関数のインデックスlocalを持つローカル変数の名前と値を返します。この関数は、明示的なローカル変数だけでなく、パラメータと一時的な値にもアクセスします。

最初のパラメータまたはローカル変数のインデックスは1であり、以下同様に、コードで宣言された順序に従い、関数の現在のスコープでアクティブな変数のみをカウントします。コンパイル時の定数は、コンパイラによって最適化された場合、このリストに表示されない場合があります。負のインデックスはvararg引数を参照します。-1は最初のvararg引数です。指定されたインデックスの変数が存在しない場合、関数はfailを返し、範囲外のレベルで呼び出された場合はエラーが発生します。（debug.getinfoを呼び出して、レベルが有効かどうかを確認できます。）

「(」（左括弧）で始まる変数名は、名前が不明な変数（ループ制御変数などの内部変数、およびデバッグ情報なしで保存されたチャンクの変数）を表します。

パラメータfは関数である場合もあります。その場合、getlocalは関数パラメータの名前のみを返します。

debug.getmetatable (value)

指定されたvalueのメタテーブルを返します。メタテーブルがない場合はnilを返します。

debug.getregistry ()

レジストリテーブルを返します（§4.3を参照）。

debug.getupvalue (f, up)

この関数は、関数fのインデックスupを持つアップバリューの名前と値を返します。指定されたインデックスを持つアップバリューがない場合は、failを返します。

（Lua関数の場合、アップバリューとは、関数が使用し、その結果としてクロージャに含まれる外部ローカル変数です。）

C言語関数の場合、この関数はすべてのアップバリューの名前として空の文字列""を使用します。

変数名'?'（疑問符）は、名前が不明な変数（デバッグ情報なしで保存されたチャンクからの変数）を表します。

debug.getuservalue (u, n)

userdata uに関連付けられたn番目のユーザー値を返し、さらに、userdataがその値を持っていない場合はfalseのブール値を返します。

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

指定された関数をデバッグフックとして設定します。文字列maskと数値countは、フックがいつ呼び出されるかを記述します。文字列マスクは、以下の文字を任意の組み合わせで持つことができ、それぞれの意味は以下のとおりです。

• 'c': Luaが関数を呼び出すたびにフックが呼び出されます。
• 'r': Luaが関数から戻るたびにフックが呼び出されます。
• 'l': Luaが新しいコード行に入るたびにフックが呼び出されます。

さらに、0以外のcountを指定すると、count命令ごとにフックが呼び出されます。

引数なしで呼び出された場合、debug.sethookはフックをオフにします。

フックが呼び出されると、その最初のパラメータは、呼び出しをトリガーしたイベントを記述する文字列です："call"、"tail call"、"return"、"line"、および"count"。行イベントの場合、フックは2番目のパラメータとして新しい行番号も取得します。フック内では、レベル2でgetinfoを呼び出して、実行中の関数に関する詳細情報を取得できます。（レベル0はgetinfo関数、レベル1はフック関数です。）

debug.setlocal ([thread,] level, local, value)

この関数は、スタックのレベルlevelにある関数のインデックスlocalを持つローカル変数に値valueを割り当てます。指定されたインデックスを持つローカル変数がない場合はfailを返し、範囲外のlevelで呼び出された場合はエラーを発生させます。（getinfoを呼び出して、レベルが有効かどうかを確認できます。）それ以外の場合は、ローカル変数の名前を返します。

変数インデックスと名前の詳細については、debug.getlocalを参照してください。

debug.setmetatable (value, table)

指定されたvalueのメタテーブルを指定されたtable（nilにすることも可能）に設定します。valueを返します。

debug.setupvalue (f, up, value)

この関数は、関数fのインデックスupを持つアップバリューに値valueを割り当てます。指定されたインデックスを持つアップバリューがない場合はfailを返します。それ以外の場合は、アップバリューの名前を返します。

アップバリューの詳細については、debug.getupvalueを参照してください。

debug.setuservalue (udata, value, n)

指定されたvalueを指定されたudataに関連付けられたn番目のユーザー値として設定します。udataは完全なuserdataである必要があります。

udataを返します。userdataがその値を持っていない場合はfailを返します。

debug.traceback ([thread,] [message [, level]])

messageが存在するが、文字列でもnilでもない場合、この関数はそれ以上の処理を行わずにmessageを返します。それ以外の場合は、コールスタックのトレースバックを含む文字列を返します。オプションのmessage文字列は、トレースバックの先頭に追加されます。オプションのlevel数値は、トレースバックを開始するレベルを指定します（デフォルトは1、tracebackを呼び出す関数です）。

debug.upvalueid (f, n)

指定された関数のn番目のアップバリューの一意の識別子（ライトuserdataとして）を返します。

これらの固有の識別子により、プログラムは異なるクロージャがアップバリューを共有しているかどうかを確認できます。アップバリューを共有する（つまり、同じ外部ローカル変数にアクセスする）Luaクロージャは、それらのアップバリューインデックスに対して同一のIDを返します。

debug.upvaluejoin (f1, n1, f2, n2)

Luaクロージャf1のn1番目のアップバリューが、Luaクロージャf2のn2番目のアップバリューを参照するようにします。

7 – Luaスタンドアロン

LuaはホストCプログラムに組み込むための拡張言語として設計されていますが、スタンドアロン言語としても頻繁に使用されます。スタンドアロン言語としてのLuaのインタープリター（単にluaと呼ばれる）は、標準ディストリビューションに付属しています。スタンドアロンインタープリターには、すべての標準ライブラリが含まれています。その使い方は次のとおりです。

     lua [options] [script [args]]

オプションは次のとおりです。

• -e stat: 文字列statを実行します。
• -i: scriptの実行後に対話モードに入ります。
• -l mod: modを「require」し、結果をグローバルmodに割り当てます。
• -l g=mod: modを「require」し、結果をグローバルgに割り当てます。
• -v: バージョン情報を出力します。
• -E: 環境変数を無視します。
• -W: 警告をオンにします。
• --: オプションの処理を停止します。
• -: stdinをファイルとして実行し、オプションの処理を停止します。

（-l g=mod形式はリリース5.4.4で導入されました。）

オプションを処理した後、luaは指定されたscriptを実行します。引数なしで呼び出された場合、標準入力（stdin）がターミナルである場合はluaはlua -v -iとして動作し、そうでない場合はlua -として動作します。

オプション-Eなしで呼び出された場合、インタープリターは、引数を実行する前に環境変数LUA_INIT_5_4（またはバージョン付きの名前が定義されていない場合はLUA_INIT）を確認します。変数の内容が@filenameの形式の場合、luaはそのファイルを実行します。それ以外の場合、luaは文字列自体を実行します。

オプション-Eを指定して呼び出された場合、Luaは環境変数を参照しません。特に、package.pathとpackage.cpathの値は、luaconf.hで定義されたデフォルトパスで設定されます。

オプション-e、-l、および-Wは、表示される順序で処理されます。たとえば、次のような呼び出しでは

     $ lua -e 'a=1' -llib1 script.lua

最初にaを1に設定し、次にライブラリlib1をrequireし、最後に引数なしでファイルscript.luaを実行します。（ここで$はシェルプロンプトです。プロンプトは異なる場合があります。）

コードを実行する前に、luaは、argという名前のグローバルテーブルにすべてのコマンドライン引数を収集します。スクリプト名はインデックス0に、スクリプト名の後の最初の引数はインデックス1に、というように続きます。スクリプト名より前の引数（つまり、インタープリター名とオプション）は負のインデックスになります。たとえば、次の呼び出しでは

     $ lua -la b.lua t1 t2

テーブルは次のようになります。

     arg = { [-2] = "lua", [-1] = "-la",
             [0] = "b.lua",
             [1] = "t1", [2] = "t2" }

呼び出しにスクリプトがない場合、インタープリター名はインデックス0になり、その後に他の引数が続きます。たとえば、次の呼び出しでは

     $ lua -e "print(arg[1])"

「-e」が出力されます。スクリプトがある場合、スクリプトは引数arg[1]、···、arg[#arg]で呼び出されます。Luaのすべてのチャンクと同様に、スクリプトは可変長引数関数としてコンパイルされます。

対話モードでは、Luaは繰り返しプロンプトを表示して行を待ちます。行を読み取った後、Luaは最初にその行を式として解釈しようとします。成功した場合は、その値を出力します。それ以外の場合は、その行をステートメントとして解釈します。不完全なステートメントを記述した場合、インタープリターは別のプロンプトを発行して完了を待ちます。

グローバル変数_PROMPTに文字列が含まれている場合、その値はプロンプトとして使用されます。同様に、グローバル変数_PROMPT2に文字列が含まれている場合、その値はセカンダリプロンプトとして使用されます（不完全なステートメント中に発行されます）。

スクリプトで保護されていないエラーが発生した場合、インタープリターは標準エラーストリームにエラーを報告します。エラーオブジェクトが文字列ではなく、メタメソッド__tostringを持つ場合、インタープリターはこのメタメソッドを呼び出して最終的なメッセージを生成します。それ以外の場合、インタープリターはエラーオブジェクトを文字列に変換し、スタックトレースバックを追加します。警告がオンの場合、警告は単に標準エラー出力に出力されます。

正常に終了すると、インタープリターはメインのLua状態を閉じます（lua_closeを参照）。スクリプトは、os.exitを呼び出して終了することにより、このステップを回避できます。

UnixシステムでLuaをスクリプトインタープリターとして使用できるようにするために、Luaはファイルチャンクの最初の行が#で始まる場合、その行をスキップします。したがって、Luaスクリプトは、chmod +xと#!形式を使用して、次のように実行可能プログラムにすることができます。

     #!/usr/local/bin/lua

もちろん、Luaインタープリターの場所はマシンによって異なる場合があります。luaがPATHにある場合、

     #!/usr/bin/env lua

よりポータブルなソリューションになります。

8 – 以前のバージョンとの非互換性

ここでは、Lua 5.3からLua 5.4にプログラムを移行する際に発生する可能性のある非互換性をリストします。

適切なオプションを使用してLuaをコンパイルすることにより、いくつかの非互換性を回避できます（ファイルluaconf.hを参照）。ただし、これらの互換性オプションはすべて将来削除されます。多くの場合、互換性の問題は、これらの互換性オプションが削除されたときに発生します。したがって、機会があれば、すべての互換性オプションをオフにしてコンパイルされたLuaのバージョンでコードをテストするようにしてください。これにより、Luaの新しいバージョンへの移行が容易になります。

Luaのバージョンでは、定数の数値や関数をマクロとして実装するなど、プログラムのソースコードの変更を意味しない方法で、C APIを常に変更できます。したがって、異なるLuaバージョン間でバイナリが互換性があると想定しないでください。新しいバージョンを使用する場合は、常にLua APIのクライアントを再コンパイルしてください。

同様に、Luaのバージョンでは、プリコンパイルされたチャンクの内部表現を常に変更できます。プリコンパイルされたチャンクは、異なるLuaバージョン間では互換性がありません。

公式ディストリビューションの標準パスは、バージョン間で変更される可能性があります。

8.1 – 言語の非互換性

• 算術演算およびビット演算における文字列の数値への強制型変換が、コア言語から削除されました。文字列ライブラリは、文字列メタメソッドを使用して、算術演算（ただしビット演算は除く）に対して同様の処理を行います。ただし、以前のバージョンとは異なり、新しい実装では、文字列内の数値の暗黙的な型が保持されます。たとえば、"1" + "2"の結果は、浮動小数点数ではなく整数になりました。
• オーバーフローするリテラル10進整数定数は、ラップアラウンドせずに浮動小数点数として読み取られます。古い動作（ラップアラウンド付きの整数として読み取る）が必要な場合は、このような定数に16進数表記を使用できます。
• __ltメタメソッドを使用して__leをエミュレートすることが削除されました。必要な場合、このメタメソッドを明示的に定義する必要があります。
• 整数に対する数値のforループのセマンティクスが一部詳細に変更されました。特に、制御変数がラップアラウンドすることはありません。
• gotoのラベルは、同じ名前のラベルが表示されている場所では宣言できません。たとえ、この他のラベルが囲んでいるブロックで宣言されていても同様です。
• オブジェクトをファイナライズするとき、Luaは関数ではない__gcメタメソッドを無視しません。値が存在する場合、任意の値が呼び出されます。（呼び出し可能でない値は、ファイナライザの呼び出し時に他のエラーと同様に警告を生成します。）

8.2 – ライブラリの非互換性

• 関数 print は、引数をフォーマットするために tostring を呼び出しません。代わりに、この機能はハードコードされています。値をどのように出力するかを変更するには、__tostring を使用する必要があります。
• 関数 math.random によって使用される擬似乱数ジェネレータは、現在、ややランダムなシードで開始されます。さらに、異なるアルゴリズムを使用しています。
• utf8 ライブラリのデコード関数は、デフォルトではサロゲートを有効なコードポイントとして受け入れません。これらの関数に追加のパラメータを指定することで、より寛容にすることができます。
• 関数 collectgarbage のオプション "setpause" と "setstepmul" は非推奨になりました。これらを設定するには、新しいオプション "incremental" を使用する必要があります。
• 関数 io.lines は、現在、1つではなく4つの値を返します。これは、load(io.lines(filename, "L")) のように、オプションのパラメータを持つ別の関数の唯一の引数として使用する場合に問題になる可能性があります。この問題を修正するには、呼び出しを括弧で囲んで、結果の数を1つに調整できます。

8.3 – APIの非互換性

• フルユーザーデータは、現在、任意の数の関連付けられたユーザー値を持つことができます。したがって、関数 lua_newuserdata, lua_setuservalue, および lua_getuservalue は、追加の引数を持つ lua_newuserdatauv, lua_setiuservalue, および lua_getiuservalue に置き換えられました。

  互換性のために、古い名前は、1つのユーザー値を想定するマクロとして引き続き機能します。ただし、ユーザー値がゼロのユーザーデータは、メモリ効率が良いことに注意してください。

• 関数 lua_resume に追加のパラメータが追加されました。この出力パラメータは、コルーチンによってyieldまたは返されたスタックのトップにある値の数を返します。(以前のバージョンでは、これらの値はスタック全体でした。)
• 関数 lua_version は、バージョン番号のアドレスではなく、バージョン番号を返します。Luaコアは、同じコアの独自の静的コピーを使用しているライブラリで正しく動作するはずであるため、同じアドレス空間を使用しているかどうかを確認する必要はありません。
• 定数 LUA_ERRGCMM は削除されました。ファイナライザのエラーは伝播されず、代わりに警告が生成されます。
• 関数 lua_gc のオプション LUA_GCSETPAUSE と LUA_GCSETSTEPMUL は非推奨になりました。これらを設定するには、新しいオプション LUA_GCINC を使用する必要があります。

9 – Luaの完全な構文

以下は、拡張BNFにおけるLuaの完全な構文です。拡張BNFでは通常、{A}は0個以上のAを、[A]はオプションのAを意味します。(演算子の優先順位については§3.4.8を参照してください。終端記号のName、Numeral、LiteralStringの説明については§3.1を参照してください。)

	chunk ::= block

	block ::= {stat} [retstat]

	stat ::=  ‘;’ | 
		 varlist ‘=’ explist | 
		 functioncall | 
		 label | 
		 break | 
		 goto Name | 
		 do block end | 
		 while exp do block end | 
		 repeat block until exp | 
		 if exp then block {elseif exp then block} [else block] end | 
		 for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end | 
		 for namelist in explist do block end | 
		 function funcname funcbody | 
		 local function Name funcbody | 
		 local attnamelist [‘=’ explist] 

	attnamelist ::=  Name attrib {‘,’ Name attrib}

	attrib ::= [‘<’ Name ‘>’]

	retstat ::= return [explist] [‘;’]

	label ::= ‘::’ Name ‘::’

	funcname ::= Name {‘.’ Name} [‘:’ Name]

	varlist ::= var {‘,’ var}

	var ::=  Name | prefixexp ‘[’ exp ‘]’ | prefixexp ‘.’ Name 

	namelist ::= Name {‘,’ Name}

	explist ::= exp {‘,’ exp}

	exp ::=  nil | false | true | Numeral | LiteralString | ‘...’ | functiondef | 
		 prefixexp | tableconstructor | exp binop exp | unop exp 

	prefixexp ::= var | functioncall | ‘(’ exp ‘)’

	functioncall ::=  prefixexp args | prefixexp ‘:’ Name args 

	args ::=  ‘(’ [explist] ‘)’ | tableconstructor | LiteralString 

	functiondef ::= function funcbody

	funcbody ::= ‘(’ [parlist] ‘)’ block end

	parlist ::= namelist [‘,’ ‘...’] | ‘...’

	tableconstructor ::= ‘{’ [fieldlist] ‘}’

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

	field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp

	fieldsep ::= ‘,’ | ‘;’

	binop ::=  ‘+’ | ‘-’ | ‘*’ | ‘/’ | ‘//’ | ‘^’ | ‘%’ | 
		 ‘&’ | ‘~’ | ‘|’ | ‘>>’ | ‘<<’ | ‘..’ | 
		 ‘<’ | ‘<=’ | ‘>’ | ‘>=’ | ‘==’ | ‘~=’ | 
		 and | or

	unop ::= ‘-’ | not | ‘#’ | ‘~’

最終更新日: 2023年5月2日 20:09:38 UTC