update locale for collectgarbage

Author: sumneko

locale/en-us/meta.lua

@@ -15,22 +15,58 @@ cgopt.restart       =
 cgopt.count         =
 'Returns the total memory in Kbytes.'
 cgopt.step          =
-'Performs a garbage-collection step.'
+[[
+Performs a garbage-collection step. This option may be followed by an integer `size`.
+If `size` is a positive n, the collector acts as if n new bytes have been allocated; if `size` is zero, the collector performs a basic step.
+In incremental mode, a basic step corresponds to the current step size; in generational mode, a basic step performs a full minor collection,
+or an incremental step if the collector has scheduled one.
+In incremental mode, the function returns `true` if the step finished a collection cycle; in generational mode, it returns `true` if the step finished a major collection.
+]]
 cgopt.setpause      =
 'Set `pause`.'
 cgopt.setstepmul    =
 'Set `step multiplier`.'
 cgopt.incremental   =
-'Change the collector mode to incremental.'
+'Changes the collector mode to incremental and returns the previous mode (either `"generational"` or `"incremental"`).'
 cgopt.generational  =
-'Change the collector mode to generational.'
+'Changes the collector mode to generational and returns the previous mode (either `"generational"` or `"incremental"`).'
 cgopt.param         =
-'Changes and/or retrieves the values of a parameter of the collector. This option must be followed by one or two extra arguments: The name of the parameter and an optional new value.'
+[[
+Changes and/or retrieves the values of a collector parameter. This option must be followed by one or two extra arguments:
+the parameter name (a string) and an optional new value (an integer in the range [0,100000]).
+The call always returns the previous value of the parameter; if no new value is given, the value is left unchanged.
+Lua stores these values in a compressed format, so the value returned as the previous value may not be exactly the last value set.
+]]
+
+gcparam.minormul    =
+'The minor multiplier.'
+gcparam.majorminor  =
+'The major-minor multiplier.'
+gcparam.minormajor  =
+'The minor-major multiplier.'
+gcparam.pause       =
+'The garbage-collector pause.'
+gcparam.stepmul     =
+'The step multiplier.'
+gcparam.stepsize    =
+'The step size.'
+
 cgopt.isrunning     =
 'Returns whether the collector is running.'
 
 collectgarbage      =
-'This function is a generic interface to the garbage collector. It performs different functions according to its first argument, `opt`.'
+[[
+Generic interface to the garbage collector. According to the first argument `opt`, it performs:
+• `"collect"`: Performs a full garbage-collection cycle (default option).
+• `"stop"`: Stops automatic execution of the collector; it runs only when explicitly invoked, until `"restart"`.
+• `"restart"`: Restarts automatic execution of the collector.
+• `"count"`: Returns the total memory in use by Lua in Kbytes (fractional; multiply by 1024 for bytes).
+• `"step"`: Performs a garbage-collection step; optional integer `size` controls behavior and return value (see `cgopt.step`).
+• `"isrunning"`: Returns whether the collector is running (i.e., not stopped).
+• `"incremental"`: Changes the mode to incremental and returns the previous mode.
+• `"generational"`: Changes the mode to generational and returns the previous mode.
+• `"param"`: Changes/reads collector parameters (see `gcparam.*`), always returns the previous value.
+]]
 
 dofile              =
 'Opens the named file and executes its content as a Lua chunk. When called without arguments, `dofile` executes the content of the standard input (`stdin`). Returns all values returned by the chunk. In case of errors, `dofile` propagates the error to its caller. (That is, `dofile` does not run in protected mode.)'

locale/es-419/meta.lua

@@ -15,22 +15,58 @@ cgopt.restart       =
 cgopt.count         =
 'Retorna el total de memoria en Kbytes.'
 cgopt.step          =
-'Realiza un paso de recolección de basura.'
+[[
+Realiza un paso de recolección de basura. Esta opción puede seguirse por un entero `size`.
+Si `size` es un n positivo, el recolector actúa como si se hubieran asignado n nuevos bytes; si `size` es cero, realiza un paso básico.
+En modo incremental, un paso básico corresponde al tamaño de paso actual; en modo generacional, un paso básico realiza una recolección menor completa,
+o un paso incremental si el recolector ha agendado uno.
+En modo incremental, la función retorna `true` si el paso terminó un ciclo de recolección; en modo generacional, retorna `true` si el paso terminó una recolección mayor.
+]]
 cgopt.setpause      =
 'Establece la pausa.'
 cgopt.setstepmul    =
 'Establece el multiplicador para el paso de recolección de basura.'
 cgopt.incremental   =
-'Cambia el modo de recolección a incremental.'
+'Cambia el modo del recolector a incremental y retorna el modo anterior (sea `"generational"` o `"incremental"`).'
 cgopt.generational  =
-'Cambia el modo de recolección a generacional.'
+'Cambia el modo del recolector a generacional y retorna el modo anterior (sea `"generational"` o `"incremental"`).'
 cgopt.param         =
-'Cambia y/o recupera los valores de un parámetro del recolector. Esta opción debe ser seguida por uno o dos argumentos extra: El nombre del parámetro y un nuevo valor opcional.'
+[[
+Cambia y/o recupera los valores de un parámetro del recolector. Esta opción debe ir seguida de uno o dos argumentos adicionales:
+el nombre del parámetro (una cadena) y un nuevo valor opcional (un entero en el rango [0,100000]).
+La llamada siempre retorna el valor anterior del parámetro; si no se da un nuevo valor, el valor se mantiene sin cambios.
+Lua almacena estos valores en un formato comprimido, por lo que el valor retornado como anterior puede no ser exactamente el último valor establecido.
+]]
+
+gcparam.minormul    =
+'El multiplicador menor.'
+gcparam.majorminor  =
+'El multiplicador mayor-menor.'
+gcparam.minormajor  =
+'El multiplicador menor-mayor.'
+gcparam.pause       =
+'La pausa del recolector de basura.'
+gcparam.stepmul     =
+'El multiplicador de paso.'
+gcparam.stepsize    =
+'El tamaño del paso.'
+
 cgopt.isrunning     =
 'Retorna si el recolector está corriendo.'
 
 collectgarbage      =
-'Esta función es una interfaz genérica al recolector de basura. Realiza diferentes funcionalidades según su primer argumento `opt`'
+[[
+Interfaz genérica al recolector de basura. Según el primer argumento `opt`, realiza:
+• `"collect"`: Realiza un ciclo completo de recolección de basura (opción predeterminada).
+• `"stop"`: Detiene la ejecución automática; el recolector corre sólo cuando se invoca explícitamente, hasta `"restart"`.
+• `"restart"`: Reinicia la ejecución automática.
+• `"count"`: Retorna la memoria total usada por Lua en Kbytes (fraccionario; multiplique por 1024 para bytes).
+• `"step"`: Realiza un paso de recolección; entero opcional `size` controla el comportamiento y el retorno (vea `cgopt.step`).
+• `"isrunning"`: Retorna si el recolector está corriendo (es decir, no detenido).
+• `"incremental"`: Cambia el modo a incremental y retorna el modo anterior.
+• `"generational"`: Cambia el modo a generacional y retorna el modo anterior.
+• `"param"`: Cambia/lee parámetros del recolector (vea `gcparam.*`), siempre retorna el valor anterior.
+]]
 
 dofile              =
 'Abre el archivo mencionado y ejecuta su contenido como un bloque Lua. Cuando es llamada sin argumentos, `dofile` ejecuta el contenido de la entrada estándar (`stdin`). Retorna todos los valores retornado por el bloque. En caso de error `dofile` propaga el error a la función que la llama. (Eso sí, `dofile` no corre en modo protegido.)'

locale/ja-jp/meta.lua

@@ -15,22 +15,58 @@ cgopt.restart       =
 cgopt.count         =
 '利用されているメモリ量の合計をキロバイト単位で返す。'
 cgopt.step          =
-'ガベージコレクションのステップを実行する。'
+[[
+ガベージコレクションのステップを実行します。このオプションの後には整数 `size` を付けることができます。
+`size` が正の n の場合、コレクタは n バイトが新たに割り当てられたかのように動作します。`size` が 0 の場合、基本ステップを実行します。
+インクリメンタルモードでは、基本ステップは現在のステップサイズに対応します。世代別モードでは、基本ステップは完全なマイナー収集、
+またはコレクタがインクリメンタルステップを予定している場合はそのインクリメンタルステップを実行します。
+インクリメンタルモードでは、ステップが収集サイクルを完了した場合に `true` を返します。世代別モードでは、ステップがメジャー収集を完了した場合に `true` を返します。
+]]
 cgopt.setpause      =
 '`pause` の値を設定する。'
 cgopt.setstepmul    =
 '`step multiplier` の値を設定する。'
 cgopt.incremental   =
-'ガベージコレクションのモードをインクリメンタルに変更する。'
+'モードをインクリメンタルに変更し、以前のモード（`"generational"` または `"incremental"`）を返します。'
 cgopt.generational  =
-'ガベージコレクションのモードを世代別に変更する。'
+'モードを世代別に変更し、以前のモード（`"generational"` または `"incremental"`）を返します。'
 cgopt.param         =
-'コレクターのパラメータの値を変更・取得する。この選択肢の後には1つまたは2つの追加引数が必要：パラメータ名と新しい値（オプション）。'
+[[
+コレクタのパラメータの値を変更／取得します。このオプションの後には 1 つまたは 2 つの追加引数が必要です：
+対象パラメータ名（文字列）と、オプションの新しい値（[0,100000] の範囲の整数）。
+呼び出しは常にそのパラメータの「以前の値」を返します。新しい値が与えられない場合、値は変更されません。Lua はこれらの値を圧縮形式で保存するため、
+返される以前の値は最後に設定された値と完全には一致しない場合があります。
+]]
+
+gcparam.minormul    =
+'マイナー乗数。'
+gcparam.majorminor  =
+'メジャー・マイナー乗数。'
+gcparam.minormajor  =
+'マイナー・メジャー乗数。'
+gcparam.pause       =
+'ガベージコレクターの一時停止。'
+gcparam.stepmul     =
+'ステップ乗数。'
+gcparam.stepsize    =
+'ステップサイズ。'
+
 cgopt.isrunning     =
 'ガベージコレクションが実行中かどうかを返す。'
 
 collectgarbage      =
-'この関数はガベージコレクション機能への汎用的なインターフェース。第一引数 `opt` に応じて異なる操作を実行する。'
+[[
+ガベージコレクタへの汎用インターフェース。第1引数 `opt` によって次を実行します：
+• `"collect"`: 完全なガベージコレクションサイクルを実行（デフォルト）。
+• `"stop"`: コレクタの自動実行を停止；`"restart"` まで明示的に呼び出したときのみ実行。
+• `"restart"`: コレクタの自動実行を再開。
+• `"count"`: Lua が使用しているメモリ総量を KBytes で返す（小数あり；1024 を掛けるとバイト数）。
+• `"step"`: ガベージコレクションのステップを実行；整数 `size` により動作と戻り値が制御される（`cgopt.step` 参照）。
+• `"isrunning"`: コレクタが実行中かどうか（停止されていないか）を返す。
+• `"incremental"`: インクリメンタルモードに変更し、以前のモードを返す。
+• `"generational"`: 世代別モードに変更し、以前のモードを返す。
+• `"param"`: コレクタのパラメータを変更／取得（`gcparam.*` 参照）。常に以前の値を返す。
+]]
 
 dofile              =
 '指定されたファイルを開き、その内容をLuaチャンクとして実行する。引数が指定されなかった場合、標準入力（`stdin`）の内容を実行する。チャンクによって返されたすべての値を返す。エラーが発生した場合、そのエラーが呼び出し元まで伝播される（つまり、`dofile` は保護モードでは実行されない）。'

locale/pt-br/meta.lua

@@ -15,22 +15,58 @@ cgopt.restart       =
 cgopt.count         =
 'Retorna, em Kbytes, a quantidade total de memória utilizada pela linguagem Lua.'
 cgopt.step          =
-'Executa a coleta de lixo (i.e., garbage-collection) em uma única etapa. A quantidade de execuções por etapa é controlada via `arg`.'
+[[
+Executa um passo do coletor de lixo. Esta opção pode ser seguida por um inteiro `size`.
+Se `size` for um n positivo, o coletor age como se n novos bytes tivessem sido alocados; se `size` for zero, o coletor executa um passo básico.
+No modo incremental, um passo básico corresponde ao tamanho de passo atual; no modo geracional, um passo básico executa uma coleta menor completa,
+ou um passo incremental, se o coletor tiver agendado um.
+No modo incremental, a função retorna `true` se o passo terminou um ciclo de coleta; no modo geracional, retorna `true` se o passo terminou uma coleta maior.
+]]
 cgopt.setpause      =
 'Estabelece pausa. Defina via `arg` o intervalo de pausa do coletor de lixo (i.e., garbage-collection).'
 cgopt.setstepmul    =
 'Estabelece um multiplicador para etapa de coleta de lixo (i.e., garbage-collection). Defina via `arg` o valor multiplicador.'
 cgopt.incremental   =
-'Altera o modo do coletor para incremental.'
+'Altera o modo do coletor para incremental e retorna o modo anterior (ou `"generational"` ou `"incremental"`).'
 cgopt.generational  =
-'Altera o modo do coletor para geracional.'
+'Altera o modo do coletor para geracional e retorna o modo anterior (ou `"generational"` ou `"incremental"`).'
 cgopt.param         =
-'Altera e/ou recupera os valores de um parâmetro do coletor. Esta opção deve ser seguida por um ou dois argumentos extras: O nome do parâmetro e um novo valor opcional.'
+[[
+Altera e/ou recupera os valores de um parâmetro do coletor. Esta opção deve ser seguida por um ou dois argumentos extras:
+o nome do parâmetro (uma string) e um novo valor opcional (um inteiro no intervalo [0,100000]).
+A chamada sempre retorna o valor anterior do parâmetro; se nenhum novo valor for dado, o valor permanece inalterado.
+O Lua armazena esses valores em um formato compactado, portanto o valor retornado como anterior pode não ser exatamente o último valor definido.
+]]
+
+gcparam.minormul    =
+'O multiplicador menor.'
+gcparam.majorminor  =
+'O multiplicador maior-menor.'
+gcparam.minormajor  =
+'O multiplicador menor-maior.'
+gcparam.pause       =
+'A pausa do coletor de lixo.'
+gcparam.stepmul     =
+'O multiplicador de passo.'
+gcparam.stepsize    =
+'O tamanho do passo.'
+
 cgopt.isrunning     =
 'Retorna um valor booleano indicando se o coletor de lixo (i.e., garbage-collection) está em execução.'
 
 collectgarbage      =
-'Esta função é uma interface genérica para o coletor de lixo (i.e., garbage-collection). Ela executa diferentes funções de acordo com seu primeiro argumento, `opt`.'
+[[
+Interface genérica para o coletor de lixo. De acordo com o primeiro argumento `opt`, executa:
+• `"collect"`: Executa um ciclo completo de coleta de lixo (opção padrão).
+• `"stop"`: Para a execução automática; o coletor só roda quando invocado explicitamente, até `"restart"`.
+• `"restart"`: Reinicia a execução automática.
+• `"count"`: Retorna a memória total usada pelo Lua em Kbytes (fracionário; multiplique por 1024 para bytes).
+• `"step"`: Executa um passo de coleta; inteiro opcional `size` controla comportamento e retorno (veja `cgopt.step`).
+• `"isrunning"`: Retorna se o coletor está rodando (ou seja, não parado).
+• `"incremental"`: Altera para modo incremental e retorna o modo anterior.
+• `"generational"`: Altera para modo geracional e retorna o modo anterior.
+• `"param"`: Altera/lê parâmetros do coletor (veja `gcparam.*`), sempre retorna o valor anterior.
+]]
 
 dofile              =
 'Abre o arquivo fornecido por argumento e executa seu conteúdo como código Lua. Quando chamado sem argumentos, `dofile` executa o conteúdo da entrada padrão (`stdin`). Retorna todos os valores retornados pelo trecho de código contido no arquivo. Em caso de erros, o `dofile` propaga o erro para seu chamador. Ou seja, o `dofile` não funciona em modo protegido.'