update
This commit is contained in:
Andrew Haynes
@@ -0,0 +1,885 @@
|
||||
---@diagnostic disable: undefined-global, lowercase-global
|
||||
|
||||
arg =
|
||||
'Argumentos de inicialização para a versão standalone da linguagem Lua.'
|
||||
|
||||
assert =
|
||||
'Emite um erro se o valor de seu argumento v for falso (i.e., `nil` ou `false`); caso contrário, devolve todos os seus argumentos. Em caso de erro, `message` é o objeto de erro que, quando ausente, por padrão é `"assertion failed!"`'
|
||||
|
||||
collectgarbage51 =
|
||||
[[
|
||||
Esta função é uma interface genérica para o coletor de lixo. Ela executa diferentes funções de acordo com seu primeiro argumento, opt:
|
||||
|
||||
* `"collect"`: executa um ciclo completo de coleta de lixo. Esta é a opção padrão.
|
||||
* `"stop"`: para o coletor de lixo.
|
||||
* `"restart"`: reinicia o coletor de lixo.
|
||||
* `"count"`: retorna a memória total em uso pelo Lua (em Kbytes).
|
||||
* `"step"`: executa uma etapa de coleta de lixo. O "tamanho" da etapa é controlado por arg (valores maiores significam mais etapas) de uma maneira não especificada. Se você quiser controlar o tamanho da etapa, deve ajustar experimentalmente o valor de arg. Retorna true se a etapa terminou um ciclo de coleta.
|
||||
* `"setpause"`: define arg como o novo valor para a pausa do coletor (ver §2.10). Retorna o valor anterior da pausa.
|
||||
* `"setstepmul"`: define arg como o novo valor para o multiplicador de etapa do coletor (ver §2.10). Retorna o valor anterior do multiplicador de etapa.
|
||||
]]
|
||||
|
||||
collectgarbage52 =
|
||||
[[
|
||||
Esta função é uma interface genérica para o coletor de lixo. Ela executa diferentes funções de acordo com seu primeiro argumento, opt:
|
||||
|
||||
* `"collect"`: executa um ciclo completo de coleta de lixo. Esta é a opção padrão.
|
||||
* `"stop"`: para a execução automática do coletor de lixo. O coletor só será executado quando invocado explicitamente, até uma chamada para reiniciá-lo.
|
||||
* `"restart"`: reinicia a execução automática do coletor de lixo.
|
||||
* `"count"`: retorna a memória total em uso pelo Lua (em Kbytes) e um segundo valor com a memória total em bytes módulo 1024. O primeiro valor tem uma parte fracionária, então a seguinte igualdade é sempre verdadeira:
|
||||
```lua
|
||||
k, b = collectgarbage("count")
|
||||
assert(k*1024 == math.floor(k)*1024 + b)
|
||||
```
|
||||
(O segundo resultado é útil quando Lua é compilado com um tipo não flutuante para números.)
|
||||
* `"step"`: executa uma etapa de coleta de lixo. O "tamanho" da etapa é controlado por arg (valores maiores significam mais etapas) de uma maneira não especificada. Se você quiser controlar o tamanho da etapa, deve ajustar experimentalmente o valor de arg. Retorna true se a etapa terminou um ciclo de coleta.
|
||||
* `"setpause"`: define arg como o novo valor para a pausa do coletor (ver §2.5). Retorna o valor anterior da pausa.
|
||||
* `"setstepmul"`: define arg como o novo valor para o multiplicador de etapa do coletor (ver §2.5). Retorna o valor anterior do multiplicador de etapa.
|
||||
* `"isrunning"`: retorna um booleano que indica se o coletor está em execução (ou seja, não parado).
|
||||
* `"generational"`: muda o coletor para o modo geracional. Este é um recurso experimental (ver §2.5).
|
||||
* `"incremental"`: muda o coletor para o modo incremental. Este é o modo padrão.
|
||||
]]
|
||||
|
||||
collectgarbage53 =
|
||||
[[
|
||||
Esta função é uma interface genérica para o coletor de lixo. Ela executa diferentes funções de acordo com seu primeiro argumento, opt:
|
||||
|
||||
* `"collect"`: executa um ciclo completo de coleta de lixo. Esta é a opção padrão.
|
||||
* `"stop"`: para a execução automática do coletor de lixo. O coletor só será executado quando invocado explicitamente, até uma chamada para reiniciá-lo.
|
||||
* `"restart"`: reinicia a execução automática do coletor de lixo.
|
||||
* `"count"`: retorna a memória total em uso pelo Lua em Kbytes. O valor tem uma parte fracionária, de modo que multiplicado por 1024 fornece o número exato de bytes em uso pelo Lua (exceto por estouros).
|
||||
* `"step"`: executa uma etapa de coleta de lixo. O "tamanho" da etapa é controlado por arg. Com um valor zero, o coletor executará uma etapa básica (indivisível). Para valores diferentes de zero, o coletor se comportará como se essa quantidade de memória (em KBytes) tivesse sido alocada pelo Lua. Retorna true se a etapa terminou um ciclo de coleta.
|
||||
* `"setpause"`: define arg como o novo valor para a pausa do coletor (ver §2.5). Retorna o valor anterior da pausa.
|
||||
* `"setstepmul"`: define arg como o novo valor para o multiplicador de etapa do coletor (ver §2.5). Retorna o valor anterior do multiplicador de etapa.
|
||||
* "isrunning"`: retorna um booleano que indica se o coletor está em execução (ou seja, não parado).
|
||||
]]
|
||||
|
||||
collectgarbage54 =
|
||||
[[
|
||||
Esta função é uma interface genérica para o coletor de lixo. Ela executa diferentes funções de acordo com seu primeiro argumento, opt:
|
||||
|
||||
* `"collect"`: Executa um ciclo completo de coleta de lixo. Esta é a opção padrão.
|
||||
* `"stop"`: Para a execução automática do coletor de lixo. O coletor só será executado quando invocado explicitamente, até uma chamada para reiniciá-lo.
|
||||
* `"restart"`: Reinicia a execução automática do coletor de lixo.
|
||||
* `"count"`: Retorna a memória total em uso pelo Lua em Kbytes. O valor tem uma parte fracionária, de modo que multiplicado por 1024 fornece o número exato de bytes em uso pelo Lua.
|
||||
* `"step"`: Executa uma etapa de coleta de lixo. O "tamanho" da etapa é controlado por arg. Com um valor zero, o coletor executará uma etapa básica (indivisível). Para valores diferentes de zero, o coletor se comportará como se essa quantidade de memória (em Kbytes) tivesse sido alocada pelo Lua. Retorna true se a etapa terminou um ciclo de coleta.
|
||||
* `"isrunning"`: Retorna um booleano que indica se o coletor está em execução (ou seja, não parado).
|
||||
* `"incremental"`: Muda o modo do coletor para incremental. Esta opção pode ser seguida por três números: a pausa do coletor de lixo, o multiplicador de etapa e o tamanho da etapa (ver §2.5.1). Um zero significa não alterar esse valor.
|
||||
* `"generational"`: Muda o modo do coletor para geracional. Esta opção pode ser seguida por dois números: o multiplicador menor do coletor de lixo e o multiplicador maior (ver §2.5.2). Um zero significa não alterar esse valor.
|
||||
Veja §2.5 para mais detalhes sobre coleta de lixo e algumas dessas opções.
|
||||
|
||||
Esta função não deve ser chamada por um finalizador.
|
||||
]]
|
||||
|
||||
collectgarbage55 =
|
||||
[[
|
||||
Esta função é uma interface genérica para o coletor de lixo. Ela executa diferentes funções de acordo com seu primeiro argumento, opt:
|
||||
|
||||
* `"collect"`: Executa um ciclo completo de coleta de lixo. Esta é a opção padrão.
|
||||
* `"stop"`: Para a execução automática do coletor de lixo. O coletor só será executado quando invocado explicitamente, até uma chamada para reiniciá-lo.
|
||||
* `"restart"`: Reinicia a execução automática do coletor de lixo.
|
||||
* `"count"`: Retorna a memória total em uso pelo Lua em Kbytes. O valor tem uma parte fracionária, de modo que multiplicado por 1024 fornece o número exato de bytes em uso pelo Lua.
|
||||
* `"step"`: Executa uma etapa de coleta de lixo. Esta opção pode ser seguida por um argumento extra, um inteiro com o tamanho da etapa.
|
||||
|
||||
Se o tamanho for um n positivo, o coletor age como se n novos bytes tivessem sido alocados. Se o tamanho for zero, o coletor executa uma etapa básica. No modo incremental, uma etapa básica corresponde ao tamanho de etapa atual. No modo geracional, uma etapa básica executa uma coleta menor completa ou uma etapa incremental, se o coletor tiver agendado uma.
|
||||
|
||||
No modo incremental, a função retorna true se a etapa terminou um ciclo de coleta. No modo geracional, a função retorna true se a etapa terminou uma coleta maior.
|
||||
|
||||
* `"isrunning"`: Retorna um booleano que indica se o coletor está em execução (ou seja, não parado).
|
||||
* `"incremental"`: Muda o modo do coletor para incremental e retorna o modo anterior.
|
||||
* `"generational"`: Muda o modo do coletor para geracional e retorna o modo anterior.
|
||||
* `"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 sendo alterado ou recuperado (uma string) e um novo valor opcional para esse parâmetro, um inteiro no intervalo [0,100000]. O primeiro argumento deve ter um dos seguintes valores:
|
||||
* `"minormul"`: O multiplicador menor.
|
||||
* `"majorminor"`: O multiplicador maior-menor.
|
||||
* `"minormajor"`: O multiplicador menor-maior.
|
||||
* `"pause"`: A pausa do coletor de lixo.
|
||||
* `"stepmul"`: O multiplicador de etapa.
|
||||
* `"stepsize"`: O tamanho da etapa.
|
||||
|
||||
A chamada sempre retorna o valor anterior do parâmetro. Se a chamada não fornecer um novo valor, o valor permanece inalterado.
|
||||
|
||||
Lua armazena esses valores em um formato compactado, então, o valor retornado como o valor anterior pode não ser exatamente o último valor definido.
|
||||
|
||||
Veja §2.5 para mais detalhes sobre coleta de lixo e algumas dessas opções.
|
||||
|
||||
Esta função não deve ser chamada por um finalizador.
|
||||
]]
|
||||
|
||||
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.'
|
||||
|
||||
error =
|
||||
[[
|
||||
Termina a última chamada de função protegida e retorna `message` como objeto de `erro`.
|
||||
|
||||
Normalmente, o 'erro' adiciona algumas informações sobre a localização do erro no início da mensagem, quando a mensagem for uma string.
|
||||
]]
|
||||
|
||||
_G =
|
||||
'Uma variável global (não uma função) que detém o ambiente global (ver §2.2). Lua em si não usa esta variável; mudar seu valor não afeta nenhum ambiente e vice-versa.'
|
||||
|
||||
getfenv =
|
||||
'Retorna o ambiente atual em uso pela função. O `f` pode ser uma função Lua ou um número que especifica a função naquele nível de pilha.'
|
||||
|
||||
getmetatable =
|
||||
'Se o objeto não tiver uma metatable, o retorno é `nil`. Mas caso a metatable do objeto tenha um campo `__metatable`, é retornado o valor associado. Caso contrário, retorna a metatable do objeto dado.'
|
||||
|
||||
ipairs =
|
||||
[[
|
||||
Retorna três valores (uma função iteradora, a tabela `t`, e `0`) para que a seguinte construção
|
||||
```lua
|
||||
for i,v in ipairs(t) do body end
|
||||
```
|
||||
possa iterar sobre os pares de valor-chave `(1,t[1]), (2,t[2]), ...`, até o primeiro índice ausente.
|
||||
]]
|
||||
|
||||
loadmode.b =
|
||||
'Somente blocos binários.'
|
||||
loadmode.t =
|
||||
'Somente blocos de texto.'
|
||||
loadmode.bt =
|
||||
'Tanto binário quanto texto.'
|
||||
|
||||
load['<5.1'] =
|
||||
'Carrega um bloco utilizando a função `func` para obter suas partes. Cada chamada para o `func` deve retornar uma string que é concatenada com os resultados anteriores.'
|
||||
load['>5.2'] =
|
||||
[[
|
||||
Carrega um bloco.
|
||||
|
||||
Se o bloco (i.e., `chunk`) é uma string, o bloco é essa string. Se o bloco é uma função, a função "load" é chamada repetidamente para obter suas partes. Cada chamada para o bloco deve retornar uma string que é concatenada com os resultados anteriores. O fim do bloco é sinalizado com o retorno de uma string vazia ou `nil`.
|
||||
]]
|
||||
|
||||
loadfile =
|
||||
'Carrega um bloco de arquivo `filename` ou da entrada padrão, se nenhum nome de arquivo for dado.'
|
||||
|
||||
loadstring =
|
||||
'Carrega um bloco a partir de uma string dada.'
|
||||
|
||||
module =
|
||||
'Cria um módulo.'
|
||||
|
||||
next =
|
||||
[[
|
||||
Permite que um programa percorra todos os campos de uma tabela. Seu primeiro argumento é uma tabela e seu segundo argumento é um índice nesta tabela. Uma chamada `next` retorna o próximo índice da tabela e seu valor associado. Quando chamado usando `nil` como segundo argumento, `next` retorna um índice inicial e seu valor associado. Quando chamado com o último índice, ou com `nil` em uma tabela vazia, o `next` retorna o `nil`. Se o segundo argumento estiver ausente, então é interpretado como `nil`. Portanto, pode-se utilizar o `next(t)` para verificar se uma tabela está vazia.
|
||||
|
||||
A ordem na qual os índices são enumerados não é especificada, *mesmo para índices numéricos*. (Para percorrer uma tabela em ordem numérica, utilize um `for`).
|
||||
|
||||
O comportamento do `next` é indefinido se, durante a iteração/travessia, você atribuir qualquer valor a um campo inexistente na tabela. Você pode, entretanto, modificar os campos existentes e pode, inclusive, os definir como nulos.
|
||||
]]
|
||||
|
||||
pairs =
|
||||
[[
|
||||
Se `t` tem um "meta" método (i.e., metamethod) `__pairs`, a chamada é feita usando t como argumento e retorna os três primeiros resultados.
|
||||
|
||||
Caso contrário, retorna três valores: a função $next, a tabela `t` e `nil`, para que a seguinte construção
|
||||
```lua
|
||||
for k,v in pairs(t) do body end
|
||||
```
|
||||
possa iterar sobre todos os pares de valor-chave da tabela 't'.
|
||||
|
||||
Veja a função $next para saber as ressalvas em modificar uma tabela durante sua iteração.
|
||||
]]
|
||||
|
||||
pcall =
|
||||
[[
|
||||
Chama a função `f` com os argumentos dados em modo *protegido*. Isto significa que qualquer erro dentro de `f` não é propagado; em vez disso, o `pcall` captura o erro e retorna um código de status. Seu primeiro resultado é o código de status (booleano), que é verdadeiro se a chamada for bem sucedida sem erros. Neste caso, `pcall' também retorna todos os resultados da chamada, após este primeiro resultado. Em caso de qualquer erro, `pcall` retorna `false` mais o objeto de erro.
|
||||
]]
|
||||
|
||||
print =
|
||||
[[
|
||||
Recebe qualquer número de argumentos e imprime seus valores na saída padrão `stdout`, convertendo cada argumento em uma string seguindo as mesmas regras do $tostring.
|
||||
A função `print` não é destinada à saída formatada, mas apenas como uma forma rápida de mostrar um valor, por exemplo, para debugging. Para controle completo sobre a saída, use $string.format e $io.write.
|
||||
]]
|
||||
|
||||
rawequal =
|
||||
'Verifica se v1 é igual a v2, sem invocar a metatable `__eq`.'
|
||||
|
||||
rawget =
|
||||
'Obtém o valor real de `table[index]`, sem invocar a metatable `__index`.'
|
||||
|
||||
rawlen =
|
||||
'Retorna o comprimento do objeto `v`, sem invocar a metatable `__len`.'
|
||||
|
||||
rawset =
|
||||
[[
|
||||
Define o valor real de `table[index]` para `value`, sem utilizar o metavalue `__newindex`. `table` deve ser uma tabela, `index` qualquer valor diferente de `nil` e `NaN`, e `value` qualquer valor de tipos do Lua.
|
||||
Esta função retorna uma `table`.
|
||||
]]
|
||||
|
||||
select =
|
||||
'Se `index` é um número, retorna todos os argumentos após o número do argumento `index`; um número negativo de índices do final (`-1` é o último argumento). Caso contrário, `index` deve ser a string `"#"`, e `select` retorna o número total de argumentos extras dados.'
|
||||
|
||||
setfenv =
|
||||
'Define o ambiente a ser utilizado pela função em questão.'
|
||||
|
||||
setmetatable =
|
||||
[[
|
||||
Define a metatable para a tabela dada. Se `metatabela` for `nil`, remove a metatable da tabela em questão. Se a metatable original tiver um campo `__metatable', um erro é lançado.
|
||||
|
||||
Esta função retorna uma `table`.
|
||||
|
||||
Para alterar a metatable de outros tipos do código Lua, você deve utilizar a biblioteca de debugging (§6.10).
|
||||
]]
|
||||
|
||||
tonumber =
|
||||
[[
|
||||
Quando chamado sem a base, `tonumber` tenta converter seu argumento para um número. Se o argumento já for um número ou uma string numérica, então `tonumber` retorna este número; caso contrário, retorna `fail`.
|
||||
|
||||
A conversão de strings pode resultar em números inteiros ou de ponto flutuante, de acordo com as convenções lexicais de Lua (ver §3.1). A string pode ter espaços antes e depois e um sinal.
|
||||
]]
|
||||
|
||||
tostring =
|
||||
[[
|
||||
Recebe um valor de qualquer tipo e o converte em uma string em formato legível por humanos.
|
||||
|
||||
Se a metatable de `v` tem um campo `__tostring', então `tostring' chama o valor correspondente usando `v` como argumento, e utiliza o resultado da chamada como seu resultado. Caso contrário, se a metatable de `v` tiver um campo `__name` com um valor do tipo string, `tostring` pode utilizar essa string em seu resultado final.
|
||||
|
||||
Para controle completo de como os números são convertidos, utilize $string.format.
|
||||
]]
|
||||
|
||||
type =
|
||||
[[
|
||||
Retorna o tipo de seu único argumento, codificado como uma string. Os resultados possíveis desta função são `"nil"` (uma string, não o valor `nil`), `"number"`, `"string"`, `"boolean"`, `"table"`, `"function"`, `"thread"`, e `"userdata"`.
|
||||
]]
|
||||
|
||||
_VERSION =
|
||||
'Uma variável global (não uma função) que contém uma string contendo a versão Lua em execução.'
|
||||
|
||||
warn =
|
||||
'Emite um aviso com uma mensagem composta pela concatenação de todos os seus argumentos (que devem ser strings).'
|
||||
|
||||
xpcall['=5.1'] =
|
||||
'Faz chamada a função `f` com os argumentos dados e em modo protegido, usando um manipulador de mensagens dado.'
|
||||
xpcall['>5.2'] =
|
||||
'Faz chamada a função `f` com os argumentos dados e em modo protegido, usando um manipulador de mensagens dado.'
|
||||
|
||||
unpack =
|
||||
[[
|
||||
Retorna os elementos da lista dada. Esta função é equivalente a
|
||||
```lua
|
||||
return list[i], list[i+1], ···, list[j]
|
||||
```
|
||||
]]
|
||||
|
||||
bit32 =
|
||||
''
|
||||
bit32.arshift =
|
||||
[[
|
||||
Retorna o número `x` deslocado `disp` bits para a direita. Deslocamentos negativos movem os bits para a esquerda.
|
||||
|
||||
Esta operação de deslocamento é chamada de deslocamento aritmético. Os bits vagos à esquerda são preenchidos com cópias do bit mais significativo de `x`; os bits vagos à direita são preenchidos com zeros.
|
||||
]]
|
||||
bit32.band =
|
||||
'Retorna a operação bitwise *and* de seus operandos.'
|
||||
bit32.bnot =
|
||||
[[
|
||||
Retorna a negação da operação bitwise de `x`.
|
||||
|
||||
```lua
|
||||
assert(bit32.bnot(x) ==
|
||||
(-1 - x) % 2^32)
|
||||
```
|
||||
]]
|
||||
bit32.bor =
|
||||
'Retorna a operação bitwise *or* de seus operandos.'
|
||||
bit32.btest =
|
||||
'Retorna um valor booleano verdadeiro se a operação bitwise *and* de seus operandos for diferente de zero. Falso, caso contrário.'
|
||||
bit32.bxor =
|
||||
'Retorna a operação bitwise *exclusive or* de seus operandos.'
|
||||
bit32.extract =
|
||||
'Retorna o número formado pelos bits de `field` a `field + width - 1` de `n`, sem sinal.'
|
||||
bit32.replace =
|
||||
'Retorna uma cópia de `n` com os bits de `field` a `field + width - 1` substituídos pelo valor `v` .'
|
||||
bit32.lrotate =
|
||||
'Retorna o número `x` rotacionado `disp` bits para a esquerda. Rotações negativos movem os bits para a direita. '
|
||||
bit32.lshift =
|
||||
[[
|
||||
Retorna o número `x` deslocado `disp` bits para a esquerda. Deslocamentos negativos movem os bits para a direita. Em ambas as direções, os bits vazios/vagos são preenchidos com zeros.
|
||||
|
||||
```lua
|
||||
assert(bit32.lshift(b, disp) ==
|
||||
(b * 2^disp) % 2^32)
|
||||
```
|
||||
]]
|
||||
bit32.rrotate =
|
||||
'Retorna o número `x` rotacionado `disp` bits para a direita. Deslocamentos negativos movem os bits para a esquerda.'
|
||||
bit32.rshift =
|
||||
[[
|
||||
Retorna o número `x` deslocado `disp` bits para a direita. Deslocamentos negativos movem os bits para a esquerda. Em ambas as direções, os bits vazios são preenchidos com zeros.
|
||||
|
||||
```lua
|
||||
assert(bit32.rshift(b, disp) ==
|
||||
math.floor(b % 2^32 / 2^disp))
|
||||
```
|
||||
]]
|
||||
|
||||
coroutine =
|
||||
''
|
||||
coroutine.create =
|
||||
'Cria uma nova `coroutine`, a partir de uma função `f` e retorna esta coroutine como objeto do tipo `"thread"`.'
|
||||
coroutine.isyieldable =
|
||||
'Retorna verdadeiro quando a `coroutine` em execução for finalizada.'
|
||||
coroutine.isyieldable['>5.4']=
|
||||
'Retorna verdadeiro quando a `coroutine` `co` for finalizada. Por padrão `co` é uma coroutine em execução.'
|
||||
coroutine.close =
|
||||
'Finaliza a coroutine `co` , encerrando todas as variáveis pendentes e colocando a coroutine em um estado morto.'
|
||||
coroutine.resume =
|
||||
'Inicia ou continua a execução da coroutine `co`.'
|
||||
coroutine.running =
|
||||
'Retorna a `coroutine` corrente e um booleana verdadeiro quando a coroutine corrente é a principal.'
|
||||
coroutine.status =
|
||||
'Retorna o status da `coroutine `co`.'
|
||||
coroutine.wrap =
|
||||
'Cria uma nova `coroutine`, a partir de uma função `f` e retorna uma função que retorna a coroutine cada vez que ele é chamado.'
|
||||
coroutine.yield =
|
||||
'Suspende a execução da coroutine chamada.'
|
||||
|
||||
costatus.running =
|
||||
'Está em execução.'
|
||||
costatus.suspended =
|
||||
'Está suspenso ou não foi iniciado.'
|
||||
costatus.normal =
|
||||
'Está ativo, mas não está em execução.'
|
||||
costatus.dead =
|
||||
'Terminou ou parou devido a erro'
|
||||
|
||||
debug =
|
||||
''
|
||||
debug.debug =
|
||||
'Entra em modo interativo com o usuário, executando os comandos de entrada.'
|
||||
debug.getfenv =
|
||||
'Retorna o ambiente do objeto `o` .'
|
||||
debug.gethook =
|
||||
'Retorna as configurações do `hook` atual da `thread`.'
|
||||
debug.getinfo =
|
||||
'Retorna uma tabela com informações sobre uma função.'
|
||||
debug.getlocal['<5.1'] =
|
||||
'Retorna o nome e o valor da variável local com índice `local` da função de nível `level` da pilha.'
|
||||
debug.getlocal['>5.2'] =
|
||||
'Retorna o nome e o valor da variável local com índice `local` da função de nível `f` da pilha.'
|
||||
debug.getmetatable =
|
||||
'Retorna a `metatable` do valor dado.'
|
||||
debug.getregistry =
|
||||
'Retorna a tabela de registro.'
|
||||
debug.getupvalue =
|
||||
'Retorna o nome e o valor da variável antecedente com índice `up` da função.'
|
||||
debug.getuservalue['<5.3'] =
|
||||
'Retorna o valor de Lua associado a `u` (i.e., user).'
|
||||
debug.getuservalue['>5.4'] =
|
||||
[[
|
||||
Retorna o `n`-ésimo valor de usuário associado
|
||||
aos dados do usuário `u` e um booleano,
|
||||
`false`, se nos dados do usuário não existir esse valor.
|
||||
]]
|
||||
debug.setcstacklimit =
|
||||
[[
|
||||
### **Deprecated in `Lua 5.4.2`**
|
||||
|
||||
Estabelece um novo limite para a pilha C. Este limite controla quão profundamente as chamadas aninhadas podem ir em Lua, com a intenção de evitar um transbordamento da pilha.
|
||||
|
||||
Em caso de sucesso, esta função retorna o antigo limite. Em caso de erro, ela retorna `false`.
|
||||
]]
|
||||
debug.setfenv =
|
||||
'Define o ambiente do `object` dado para a `table` dada .'
|
||||
debug.sethook =
|
||||
'Define a função dada como um `hook`.'
|
||||
debug.setlocal =
|
||||
'Atribui o valor `value` à variável local com índice `local` da função de nível `level` da pilha.'
|
||||
debug.setmetatable =
|
||||
'Define a `metatable` com o valor dado para tabela dada (que pode ser `nil`).'
|
||||
debug.setupvalue =
|
||||
'Atribui `value` a variável antecedente com índice `up` da função.'
|
||||
debug.setuservalue['<5.3'] =
|
||||
'Define o valor dado como o valor Lua associado ao `udata` (i.e., user data).'
|
||||
debug.setuservalue['>5.4'] =
|
||||
[[
|
||||
Define o valor dado como
|
||||
o `n`-ésimo valor de usuário associado ao `udata` (i.e., user data).
|
||||
O `udata` deve ser um dado de usuário completo.
|
||||
]]
|
||||
debug.traceback =
|
||||
'Retorna uma string com um `traceback` de chamadas. A string de mensagen (opcional) é anexada no início do traceback.'
|
||||
debug.upvalueid =
|
||||
'Retorna um identificador único (como um dado de usuário leve) para o valor antecedente de numero `n` da função dada.'
|
||||
debug.upvaluejoin =
|
||||
'Faz o `n1`-ésimo valor da função `f1` (i.e., closure Lua) referir-se ao `n2`-ésimo valor da função `f2`.'
|
||||
|
||||
infowhat.n =
|
||||
'`name` e `namewhat`'
|
||||
infowhat.S =
|
||||
'`source`, `short_src`, `linedefined`, `lastlinedefined` e `what`'
|
||||
infowhat.l =
|
||||
'`currentline`'
|
||||
infowhat.t =
|
||||
'`istailcall`'
|
||||
infowhat.u['<5.1'] =
|
||||
'`nups`'
|
||||
infowhat.u['>5.2'] =
|
||||
'`nups`, `nparams` e `isvararg`'
|
||||
infowhat.f =
|
||||
'`func`'
|
||||
infowhat.r =
|
||||
'`ftransfer` e `ntransfer`'
|
||||
infowhat.L =
|
||||
'`activelines`'
|
||||
|
||||
hookmask.c =
|
||||
'Faz chamada a um `hook` quando o Lua chama uma função.'
|
||||
hookmask.r =
|
||||
'Faz chamada a um `hook` quando o retorno de uma função é executado.'
|
||||
hookmask.l =
|
||||
'Faz chamada a um `hook` quando encontra nova linha de código.'
|
||||
|
||||
file =
|
||||
''
|
||||
file[':close'] =
|
||||
'Fecha o arquivo `file`.'
|
||||
file[':flush'] =
|
||||
'Salva qualquer dado de entrada no arquivo `file`.'
|
||||
file[':lines'] =
|
||||
[[
|
||||
------
|
||||
```lua
|
||||
for c in file:lines(...) do
|
||||
body
|
||||
end
|
||||
```
|
||||
]]
|
||||
file[':read'] =
|
||||
'Lê o arquivo de acordo com o formato fornecido e que especifica o que deve ser lido.'
|
||||
file[':seek'] =
|
||||
'Define e obtém a posição do arquivo, medida a partir do início do arquivo.'
|
||||
file[':setvbuf'] =
|
||||
'Define o modo de `buffer` para um arquivo de saída.'
|
||||
file[':write'] =
|
||||
'Escreve o valor de cada um de seus argumentos no arquivo.'
|
||||
|
||||
readmode.n =
|
||||
'Lê um numeral e o devolve como número.'
|
||||
readmode.a =
|
||||
'Lê o arquivo completo.'
|
||||
readmode.l =
|
||||
'Lê a próxima linha pulando o final da linha.'
|
||||
readmode.L =
|
||||
'Lê a próxima linha mantendo o final da linha.'
|
||||
|
||||
seekwhence.set =
|
||||
'O cursor base é o início do arquivo.'
|
||||
seekwhence.cur =
|
||||
'O cursor base é a posição atual.'
|
||||
seekwhence['.end'] =
|
||||
'O cursor base é o final do arquivo.'
|
||||
|
||||
vbuf.no =
|
||||
'A saída da operação aparece imediatamente.'
|
||||
vbuf.full =
|
||||
'Realizado apenas quando o `buffer` está cheio.'
|
||||
vbuf.line =
|
||||
'`Buffered` até que uma nova linha seja encontrada.'
|
||||
|
||||
io =
|
||||
''
|
||||
io.stdin =
|
||||
'Entrada padrão.'
|
||||
io.stdout =
|
||||
'Saída padrão.'
|
||||
io.stderr =
|
||||
'Erro padrão.'
|
||||
io.close =
|
||||
'Fecha o arquivo dado ou o arquivo de saída padrão.'
|
||||
io.flush =
|
||||
'Salva todos os dados gravados no arquivo de saída padrão.'
|
||||
io.input =
|
||||
'Define o arquivo de entrada padrão.'
|
||||
io.lines =
|
||||
[[
|
||||
------
|
||||
```lua
|
||||
for c in io.lines(filename, ...) do
|
||||
body
|
||||
end
|
||||
```
|
||||
]]
|
||||
io.open =
|
||||
'Abre um arquivo no modo especificado pela *string* `mode`.'
|
||||
io.output =
|
||||
'Define o arquivo de saída padrão.'
|
||||
io.popen =
|
||||
'Inicia o programa dado em um processo separado.'
|
||||
io.read =
|
||||
'Lê o arquivo de acordo com o formato fornecido e que especifica o que deve ser lido.'
|
||||
io.tmpfile =
|
||||
'Em caso de sucesso, retorna um `handler` para um arquivo temporário.'
|
||||
io.type =
|
||||
'Verifica se `obj` é um identificador de arquivo válido.'
|
||||
io.write =
|
||||
'Escreve o valor de cada um dos seus argumentos para o arquivo de saída padrão.'
|
||||
|
||||
openmode.r =
|
||||
'Modo de leitura.'
|
||||
openmode.w =
|
||||
'Modo de escrita.'
|
||||
openmode.a =
|
||||
'Modo de anexação.'
|
||||
openmode['.r+'] =
|
||||
'Modo de atualização, todos os dados anteriores são preservados.'
|
||||
openmode['.w+'] =
|
||||
'Modo de atualização, todos os dados anteriores são apagados.'
|
||||
openmode['.a+'] =
|
||||
'Modo de anexação e atualização, os dados anteriores são preservados, a escrita só é permitida no final do arquivo.'
|
||||
openmode.rb =
|
||||
'Modo de leitura. (em modo binário)'
|
||||
openmode.wb =
|
||||
'Modo de escrita. (em modo binário)'
|
||||
openmode.ab =
|
||||
'Modo de anexação. (em modo binário)'
|
||||
openmode['.r+b'] =
|
||||
'Modo de atualização, todos os dados anteriores são preservados. (em modo binário)'
|
||||
openmode['.w+b'] =
|
||||
'Modo de atualização, todos os dados anteriores são apagados. (em modo binário)'
|
||||
openmode['.a+b'] =
|
||||
'Modo de anexação e atualização, todos os dados anteriores são preservados, a escrita só é permitida no final do arquivo. (em modo binário)'
|
||||
|
||||
popenmode.r =
|
||||
'Leia dados deste programa pelo arquivo.'
|
||||
popenmode.w =
|
||||
'Escreva dados neste programa pelo arquivo.'
|
||||
|
||||
filetype.file =
|
||||
'`handler` para arquivo aberto.'
|
||||
filetype['.closed file'] =
|
||||
'`handler` para arquivo fechado.'
|
||||
filetype['.nil'] =
|
||||
'Não é um `handler` de arquivo'
|
||||
|
||||
math =
|
||||
''
|
||||
math.abs =
|
||||
'Retorna o valor absoluto de `x`.'
|
||||
math.acos =
|
||||
'Retorna o arco cosseno de `x` (em radianos).'
|
||||
math.asin =
|
||||
'Retorna o arco seno de `x` (em radianos).'
|
||||
math.atan['<5.2'] =
|
||||
'Retorna o arco tangente de `x` (em radianos).'
|
||||
math.atan['>5.3'] =
|
||||
'Retorna o arco tangente de `y/x` (em radianos).'
|
||||
math.atan2 =
|
||||
'Retorna o arco tangente de `y/x` (em radianos).'
|
||||
math.ceil =
|
||||
'Retorna o menor valor inteiro maior ou igual a `x`.'
|
||||
math.cos =
|
||||
'Retorna o cosseno de `x` (requer valor em radianos).'
|
||||
math.cosh =
|
||||
'Retorna o cosseno hiperbólico de `x` (requer valor em radianos).'
|
||||
math.deg =
|
||||
'Converte o ângulo `x` de radianos para graus.'
|
||||
math.exp =
|
||||
'Retorna o valor `e^x` (onde `e` é a base do logaritmo natural).'
|
||||
math.floor =
|
||||
'Retorna o maior valor inteiro menor ou igual a `x`.'
|
||||
math.fmod =
|
||||
'Retorna o resto da divisão de `x` por `y` que arredonda o quociente para zero.'
|
||||
math.frexp =
|
||||
'Decompõe `x` em fatores e expoentes. Retorna `m` e `e` tal que `x = m * (2 ^ e)` é um inteiro e o valor absoluto de `m` está no intervalo [0,5, 1) (ou zero quando `x` é zero).'
|
||||
math.huge =
|
||||
'Um valor maior que qualquer outro valor numérico.'
|
||||
math.ldexp =
|
||||
'Retorna `m * (2 ^ e)`.'
|
||||
math.log['<5.1'] =
|
||||
'Retorna o logaritmo natural de `x`.'
|
||||
math.log['>5.2'] =
|
||||
'Retorna o logaritmo de `x` na base dada.'
|
||||
math.log10 =
|
||||
'Retorna o logaritmo `x` na base 10.'
|
||||
math.max =
|
||||
'Retorna o argumento com o valor máximo de acordo com o operador `<`.'
|
||||
math.maxinteger['>5.3'] =
|
||||
'Retorna o valor máximo para um inteiro.'
|
||||
math.min =
|
||||
'Retorna o argumento com o valor mínimo de acordo com o operador `<`.'
|
||||
math.mininteger['>5.3'] =
|
||||
'Retorna o valor mínimo para um inteiro.'
|
||||
math.modf =
|
||||
'Retorna a parte inteira e a parte fracionária de `x`.'
|
||||
math.pi =
|
||||
'O valor de *π*.'
|
||||
math.pow =
|
||||
'Retorna `x ^ y`.'
|
||||
math.rad =
|
||||
'Converte o ângulo `x` de graus para radianos.'
|
||||
math.random =
|
||||
[[
|
||||
* `math.random()`: Retorna um valor real (i.e., ponto flutuante) no intervalo [0,1).
|
||||
* `math.random(n)`: Retorna um inteiro no intervalo [1, n].
|
||||
* `math.random(m, n)`: Retorna um inteiro no intervalo [m, n].
|
||||
]]
|
||||
math.randomseed['<5.3'] =
|
||||
'Define `x` como valor semente (i.e., `seed`) para a função geradora de números pseudo-aleatória.'
|
||||
math.randomseed['>5.4'] =
|
||||
[[
|
||||
* `math.randomseed(x, y)`: Concatena `x` e `y` em um espaço de 128-bits que é usado como valor semente (`seed`) para reinicializar o gerador de números pseudo-aleatório.
|
||||
* `math.randomseed(x)`: Equivale a `math.randomseed(x, 0)` .
|
||||
* `math.randomseed()`: Gera um valor semente (i.e., `seed`) com fraca probabilidade de aleatoriedade.
|
||||
]]
|
||||
math.sin =
|
||||
'Retorna o seno de `x` (requer valor em radianos).'
|
||||
math.sinh =
|
||||
'Retorna o seno hiperbólico de `x` (requer valor em radianos).'
|
||||
math.sqrt =
|
||||
'Retorna a raiz quadrada de `x`.'
|
||||
math.tan =
|
||||
'Retorna a tangente de `x` (requer valor em radianos).'
|
||||
math.tanh =
|
||||
'Retorna a tangente hiperbólica de `x` (requer valor em radianos).'
|
||||
math.tointeger['>5.3'] =
|
||||
'Se o valor `x` pode ser convertido para um inteiro, retorna esse inteiro.'
|
||||
math.type['>5.3'] =
|
||||
'Retorna `"integer"` se `x` é um inteiro, `"float"` se for um valor real (i.e., ponto flutuante), ou `nil` se `x` não é um número.'
|
||||
math.ult['>5.3'] =
|
||||
'Retorna `true` se e somente se `m` é menor `n` quando eles são comparados como inteiros sem sinal.'
|
||||
|
||||
os =
|
||||
''
|
||||
os.clock =
|
||||
'Retorna uma aproximação do valor, em segundos, do tempo de CPU usado pelo programa.'
|
||||
os.date =
|
||||
'Retorna uma string ou uma tabela contendo data e hora, formatada de acordo com a string `format` fornecida.'
|
||||
os.difftime =
|
||||
'Retorna a diferença, em segundos, do tempo `t1` para o tempo` t2`.'
|
||||
os.execute =
|
||||
'Passa `command` para ser executado por um `shell` do sistema operacional.'
|
||||
os.exit['<5.1'] =
|
||||
'Chama a função `exit` do C para encerrar o programa.'
|
||||
os.exit['>5.2'] =
|
||||
'Chama a função `exit` do ISO C para encerrar o programa.'
|
||||
os.getenv =
|
||||
'Retorna o valor da variável de ambiente de processo `varname`.'
|
||||
os.remove =
|
||||
'Remove o arquivo com o nome dado.'
|
||||
os.rename =
|
||||
'Renomeia o arquivo ou diretório chamado `oldname` para `newname`.'
|
||||
os.setlocale =
|
||||
'Define a localidade atual do programa.'
|
||||
os.time =
|
||||
'Retorna a hora atual quando chamada sem argumentos, ou um valor representando a data e a hora local especificados pela tabela fornecida.'
|
||||
os.tmpname =
|
||||
'Retorna uma string com um nome de arquivo que pode ser usado como arquivo temporário.'
|
||||
|
||||
osdate.year =
|
||||
'Quatro dígitos.'
|
||||
osdate.month =
|
||||
'1-12'
|
||||
osdate.day =
|
||||
'1-31'
|
||||
osdate.hour =
|
||||
'0-23'
|
||||
osdate.min =
|
||||
'0-59'
|
||||
osdate.sec =
|
||||
'0-61'
|
||||
osdate.wday =
|
||||
'Dia da semana, 1–7, Domingo é 1'
|
||||
osdate.yday =
|
||||
'Dia do ano, 1–366'
|
||||
osdate.isdst =
|
||||
'Bandeira para indicar horário de verão (i.e., `Daylight Saving Time`), um valor booleano.'
|
||||
|
||||
package =
|
||||
''
|
||||
|
||||
require['<5.3'] =
|
||||
'Carrega o módulo fornecido e retorna qualquer valor retornado pelo módulo (`true` quando `nil`).'
|
||||
require['>5.4'] =
|
||||
'Carrega o módulo fornecido e retorna qualquer valor retornado pelo pesquisador (`true` quando `nil`). Além desse valor, também retorna como segundo resultado um carregador de dados retornados pelo pesquisador, o que indica como `require` encontrou o módulo. (Por exemplo, se o módulo vier de um arquivo, este carregador de dados é o caminho do arquivo.)'
|
||||
|
||||
package.config =
|
||||
'string descrevendo configurações a serem utilizadas durante a compilação de pacotes.'
|
||||
package.cpath =
|
||||
'O caminho usado pelo `require` para procurar pelo carregador C.'
|
||||
package.loaded =
|
||||
'Uma tabela usada pelo `require` para controlar quais módulos já estão carregados.'
|
||||
package.loaders =
|
||||
'Uma tabela usada pelo `require` para controlar como carregar módulos.'
|
||||
package.loadlib =
|
||||
'Dinamicamente vincula o programa no `host` com a biblioteca C `libname`.'
|
||||
package.path =
|
||||
'O caminho usado pelo `require` para procurar por um carregador Lua.'
|
||||
package.preload =
|
||||
'Uma tabela para armazenar carregadores de módulos específicos.'
|
||||
package.searchers =
|
||||
'Uma tabela usada pelo `require` para controlar como buscar módulos.'
|
||||
package.searchpath =
|
||||
'Procura por `name` em `path`.'
|
||||
package.seeall =
|
||||
'Define uma `metatable` `module` com o campo `__index` referenciando o ambiente global, para que este módulo herde valores do ambiente global. Para ser usado como uma opção a função `module`.'
|
||||
|
||||
string =
|
||||
''
|
||||
string.byte =
|
||||
'Retorna os códigos numéricos internos dos caracteres `s[i], s[i+1], ..., s[j]`.'
|
||||
string.char =
|
||||
'Retorna uma string com comprimento igual ao número de argumentos, no qual cada caractere possui o código numérico interno igual ao seu argumento correspondente.'
|
||||
string.dump =
|
||||
'Retorna uma string contendo uma representação binária (i.e., *binary chunk*) da função dada.'
|
||||
string.find =
|
||||
'Procura a primeira correspondencia de `pattern` (veja §6.4.1) na string.'
|
||||
string.find['>5.2'] =
|
||||
'Procura a primeira correspondência de `pattern` (veja §6.4.1) na string.'
|
||||
string.find['=5.1'] =
|
||||
'Procura a primeira correspondência de `pattern` (veja §5.4.1) na string.'
|
||||
string.format =
|
||||
'Retorna uma versão formatada de seu número variável de argumentos após a descrição dada em seu primeiro argumento.'
|
||||
string.gmatch =
|
||||
[[
|
||||
Retorna um iterator que, a cada vez que é chamado, retorna as próximas capturas de `pattern` (veja §6.4.1) sobre a string *s*.
|
||||
|
||||
Por exemplo, o loop a seguir irá iterar em todas as palavras da string *s*, imprimindo cada palavra por linha:
|
||||
```lua
|
||||
s =
|
||||
"hello world from Lua"
|
||||
for w in string.gmatch(s, "%a+") do
|
||||
print(w)
|
||||
end
|
||||
```
|
||||
]]
|
||||
string.gsub =
|
||||
'Retorna uma cópia da *s* em que todas ou, caso fornecido, as primeiras `n` ocorrências de `pattern` (veja §6.4.1) que tiverem sido substituídas por uma string de substituição especificada por `repl`.'
|
||||
string.gmatch['>5.2'] =
|
||||
[[
|
||||
Retorna uma função iteradora que, a cada vez que é chamada, retorna as próximas capturas de `pattern` (veja §6.4.1) sobre a string s.
|
||||
|
||||
Por exemplo, o loop a seguir irá iterar em todas as palavras da string s, imprimindo cada palavra por linha:
|
||||
```lua
|
||||
s =
|
||||
"hello world from Lua"
|
||||
for w in string.gmatch(s, "%a+") do
|
||||
print(w)
|
||||
end
|
||||
```
|
||||
]]
|
||||
string.gmatch['=5.1'] =
|
||||
[[
|
||||
Retorna uma função iteradora que, a cada vez que é chamada, retorna as próximas capturas de `pattern` (veja §5.4.1) sobre a string s.
|
||||
|
||||
Por exemplo, o loop a seguir irá iterar em todas as palavras da string s, imprimindo cada palavra por linha:
|
||||
```lua
|
||||
s =
|
||||
"hello world from Lua"
|
||||
for w in string.gmatch(s, "%a+") do
|
||||
print(w)
|
||||
end
|
||||
```
|
||||
]]
|
||||
string.gsub['>5.2'] =
|
||||
'Retorna uma cópia de s em que todas ou, caso fornecido, as primeiras `n` ocorrências de `pattern` (veja §6.4.1) que tiverem sido substituídas por uma string de substituição especificada por `repl`.'
|
||||
string.gsub['=5.1'] =
|
||||
'Retorna uma cópia de s em que todas ou, caso fornecido, as primeiras `n` ocorrências de `pattern` (veja §5.4.1) que tiverem sido substituídas por uma string de substituição especificada por `repl`.'
|
||||
string.len =
|
||||
'Retorna o comprimento da string.'
|
||||
string.lower =
|
||||
'Retorna uma cópia desta string com todas as letras maiúsculas alteradas para minúsculas.'
|
||||
string.match =
|
||||
'Procura a primeira ocorrência do `pattern` (veja §6.4.1) na string.'
|
||||
string.pack =
|
||||
'Retorna uma string binária contendo os valores `V1`, `v2`, etc. empacotados (isto é, serializado de forma binário) de acordo com o formato da string `fmt` fornecida (veja §6.4.2).'
|
||||
string.packsize =
|
||||
'Retorna o tamanho de uma string resultante de `string.pack` com o formato da string `fmt` fornecida (veja §6.4.2).'
|
||||
string.match['>5.2'] =
|
||||
'Procura a primeira ocorrência do `pattern` (veja §6.4.1) na string.'
|
||||
string.match['=5.1'] =
|
||||
'Procura a primeira ocorrência do `pattern` (veja §5.4.1) na string.'
|
||||
string.pack['>5.2'] =
|
||||
'Retorna uma string binária contendo os valores `v1`, `v2`, etc. empacotados (isto é, serializados em formato binário) de acordo com a string de formato `fmt` (veja §6.4.2).'
|
||||
string.packsize['>5.2'] =
|
||||
'Retorna o tamanho de uma string resultante de `string.pack` com a string de formato `fmt` fornecida (veja §6.4.2).'
|
||||
string.rep['>5.2'] =
|
||||
'Retorna uma string que é a concatenação de `n` cópias da string `s` separadas pela string `sep`.'
|
||||
string.rep['<5.1'] =
|
||||
'Retorna uma string que é a concatenação de `n` cópias da string `s`.'
|
||||
string.reverse =
|
||||
'Retorna uma string que representa a string `s` invertida.'
|
||||
string.sub =
|
||||
'Retorna a substring da string `s` que começa no índice `i` e continua até o índice `j`.'
|
||||
string.unpack =
|
||||
'Retorna os valores empacotados na string de acordo com o formato da string `fmt` fornecida (veja §6.4.2).'
|
||||
string.upper =
|
||||
'Retorna uma cópia desta string com todas as letras minúsculas alteradas para maiúsculas.'
|
||||
|
||||
table =
|
||||
''
|
||||
table.concat =
|
||||
'Dada uma lista onde todos os elementos são strings ou números, retorna a string `list[i]..sep..list[i+1] ··· sep..list[j]`.'
|
||||
table.create =
|
||||
'Cria uma nova tabela vazia, pré-alocando memória. Esta pré-alocação pode ajudar no desempenho e economizar memória quando você souber com antecedência quantos elementos a tabela terá. O parâmetro `nseq` é uma dica para quantos elementos a tabela terá como sequência. O parâmetro opcional `nrec` é uma dica para quantos outros elementos a tabela terá; seu padrão é zero.'
|
||||
table.insert =
|
||||
'Insere o elemento `value` na posição `pos` de `list`.'
|
||||
table.maxn =
|
||||
'Retorna o maior índice numérico positivo da tabela fornecida ou zero se a tabela não tiver índices numéricos positivos.'
|
||||
table.move =
|
||||
[[
|
||||
Move os elementos da tabela `a1` para tabela `a2`.
|
||||
```lua
|
||||
a2[t],··· =
|
||||
a1[f],···,a1[e]
|
||||
return a2
|
||||
```
|
||||
]]
|
||||
table.pack =
|
||||
'Retorna uma nova tabela com todos os argumentos armazenados em chaves `1`, `2`, etc. e com um campo `"n"` com o número total de argumentos.'
|
||||
table.remove =
|
||||
'Remove de `list` o elemento na posição `pos`, retornando o valor do elemento removido.'
|
||||
table.sort =
|
||||
'Ordena os elementos de `list` em uma determinada ordem, *in-place*, de `list[1]` para `list[#list]`.'
|
||||
table.unpack =
|
||||
[[
|
||||
Retorna os elementos da lista fornecida. Esta função é equivalente a
|
||||
```lua
|
||||
return list[i], list[i+1], ···, list[j]
|
||||
```
|
||||
Por padrão, `i` é `1` e `j` é `#list`.
|
||||
]]
|
||||
table.foreach =
|
||||
'Executa a função f fornecida sobre todos os elementos da tabela. Para cada elemento, f é chamada com o índice e o valor respectivo como argumentos. Se f retornar um valor não-nil, o loop é interrompido e esse valor é retornado como valor final de foreach.'
|
||||
table.foreachi =
|
||||
'Executa a função f fornecida sobre os índices numéricos da tabela. Para cada índice, f é chamada com o índice e o valor respectivo como argumentos. Índices são visitados em ordem sequencial, de 1 a n, onde n é o tamanho da tabela. Se f retornar um valor não-nil, o loop é interrompido e esse valor é retornado como resultado de foreachi.'
|
||||
table.getn =
|
||||
'Retorna o número de elementos na tabela. Esta função é equivalente a `#list`.'
|
||||
table.new =
|
||||
[[Cria uma tabela pré-dimensionada, assim como o equivalente da C API `lua_createtable()`. É útil para tabelas grandes se o tamanho final for conhecido e o redimensionamento automático for muito custoso. O parâmetro `narray` especifica o número de itens tipo array, e o parâmetro `nhash` especifica o número de itens tipo hash. A função precisa ser requerida antes do uso.
|
||||
```lua
|
||||
require("table.new")
|
||||
```
|
||||
]]
|
||||
table.clear =
|
||||
[[Limpa todas as chaves e valores de uma tabela, mas preserva os tamanhos alocados das partes array/hash. É útil quando uma tabela, que está vinculada de vários lugares, precisa ser limpa e/ou quando se recicla uma tabela para uso pelo mesmo contexto. Evita gerenciar backlinks, economiza uma alocação e o custo de crescimento incremental das partes array/hash. A função precisa ser requerida antes do uso.
|
||||
```lua
|
||||
require("table.clear").
|
||||
```
|
||||
Observe que esta função é destinada a situações muito específicas. Na maioria dos casos, é melhor substituir o link (único geralmente) por uma nova tabela e deixar o GC fazer seu trabalho.
|
||||
]]
|
||||
|
||||
utf8 =
|
||||
''
|
||||
utf8.char =
|
||||
'Recebe zero ou mais inteiros, converte cada um à sua sequência de byte UTF-8 correspondente e retorna uma string com a concatenação de todas essas sequências.'
|
||||
utf8.charpattern =
|
||||
'O padrão que corresponde exatamente uma sequência de byte UTF-8, supondo que seja uma sequência válida UTF-8.'
|
||||
utf8.codes =
|
||||
[[
|
||||
Retorna valores tal que a seguinte construção
|
||||
```lua
|
||||
for p, c in utf8.codes(s) do
|
||||
body
|
||||
end
|
||||
```
|
||||
itere em todos os caracteres UTF-8 na string s, com p sendo a posição (em bytes) e c o *codepoint* de cada caractere. Ele gera um erro se encontrado qualquer sequência de byte inválida.
|
||||
]]
|
||||
utf8.codepoint =
|
||||
'Retorna os *codepoints* (em inteiros) de todos os caracteres em `s` que iniciam entre as posições do byte `i` e `j` (ambos inclusos).'
|
||||
utf8.len =
|
||||
'Retorna o número de caracteres UTF-8 na string `s` que começa entre as posições `i` e `j` (ambos inclusos).'
|
||||
utf8.offset =
|
||||
'Retorna a posição (em bytes) onde a codificação do `n`-ésimo caractere de `s` inícia (contando a partir da posição `i`).'
|
||||
utf8.offset['55'] =
|
||||
'Retorna a posição do n-ésimo caractere de `s` (contando a partir da posição de byte `i`) como dois inteiros: o índice (em bytes) onde sua codificação começa e o índice (em bytes) onde ela termina.'
|
||||
+1341
File diff suppressed because it is too large
Load Diff
+483
@@ -0,0 +1,483 @@
|
||||
---@diagnostic disable: undefined-global
|
||||
|
||||
config.addonManager.enable =
|
||||
"Habilita ou desabilita o gerenciador de add-ons."
|
||||
config.addonManager.repositoryBranch =
|
||||
"Define o branch Git usado pelo gerenciador de add-ons."
|
||||
config.addonManager.repositoryPath =
|
||||
"Define o caminho Git usado pelo gerenciador de add-ons."
|
||||
config.addonRepositoryPath =
|
||||
"Define o caminho do repositório de add-ons (não relacionado ao gerenciador de add-ons)."
|
||||
config.runtime.version =
|
||||
"Versão do runtime Lua."
|
||||
config.runtime.path =
|
||||
[[
|
||||
Ao usar `require`, define como encontrar o arquivo baseado no nome fornecido.
|
||||
Definir esta configuração como `?/init.lua` significa que ao executar `require 'myfile'`, será buscado `${workspace}/myfile/init.lua` nos arquivos carregados.
|
||||
Se `runtime.pathStrict` for `false`, `${workspace}/**/myfile/init.lua` também será buscado.
|
||||
Para carregar arquivos fora da workspace, primeiro configure `Lua.workspace.library`.
|
||||
]]
|
||||
config.runtime.pathStrict =
|
||||
'Quando habilitado, `runtime.path` buscará apenas o primeiro nível de diretórios; veja a descrição de `runtime.path`.'
|
||||
config.runtime.special =
|
||||
[[Variáveis globais personalizadas são tratadas como variáveis especiais internas, e o servidor fornecerá suporte especial.
|
||||
O exemplo a seguir mostra que 'include' é tratado como 'require'.
|
||||
```json
|
||||
"Lua.runtime.special" : {
|
||||
"include" : "require"
|
||||
}
|
||||
```
|
||||
]]
|
||||
config.runtime.unicodeName =
|
||||
"Permite caracteres Unicode em nomes."
|
||||
config.runtime.nonstandardSymbol =
|
||||
"Suporta símbolos não-padrão. Certifique-se de que seu ambiente de runtime suporta esses símbolos."
|
||||
config.runtime.plugin =
|
||||
"Caminho do plugin. Leia a [wiki](https://luals.github.io/wiki/plugins) para saber mais."
|
||||
config.runtime.pluginArgs =
|
||||
"Argumentos adicionais para o plugin."
|
||||
config.runtime.fileEncoding =
|
||||
"Codificação de arquivo. A opção `ansi` está disponível apenas na plataforma `Windows`."
|
||||
config.runtime.builtin =
|
||||
[[
|
||||
Ajusta o estado de habilitação das bibliotecas internas. Você pode desabilitar (ou redefinir) bibliotecas inexistentes conforme o ambiente de execução real.
|
||||
|
||||
* `default`: a biblioteca será habilitada ou desabilitada conforme a versão do runtime
|
||||
* `enable`: sempre habilitar
|
||||
* `disable`: sempre desabilitar
|
||||
]]
|
||||
config.runtime.meta =
|
||||
'Formato do nome do diretório dos arquivos meta.'
|
||||
config.diagnostics.enable =
|
||||
"Habilita diagnósticos."
|
||||
config.diagnostics.disable =
|
||||
"Diagnósticos desabilitados (use o código nos colchetes do hover)."
|
||||
config.diagnostics.globals =
|
||||
"Variáveis globais definidas."
|
||||
config.diagnostics.globalsRegex =
|
||||
"Encontra variáveis globais definidas usando regex."
|
||||
config.diagnostics.severity =
|
||||
[[
|
||||
Modifica a gravidade do diagnóstico.
|
||||
|
||||
Terminar com `!` significa sobrescrever a configuração de grupo `diagnostics.groupSeverity`.
|
||||
]]
|
||||
config.diagnostics.neededFileStatus =
|
||||
[[
|
||||
* Opened: diagnosticar apenas arquivos abertos
|
||||
* Any: diagnosticar todos os arquivos
|
||||
* None: desabilitar este diagnóstico
|
||||
|
||||
Terminar com `!` significa sobrescrever a configuração de grupo `diagnostics.groupFileStatus`.
|
||||
]]
|
||||
config.diagnostics.groupSeverity =
|
||||
[[
|
||||
Modifica a gravidade do diagnóstico em um grupo.
|
||||
`Fallback` significa que os diagnósticos deste grupo são controlados por `diagnostics.severity` separadamente.
|
||||
Outras configurações sobrescreverão configurações individuais sem terminar com `!`.
|
||||
]]
|
||||
config.diagnostics.groupFileStatus =
|
||||
[[
|
||||
Modifica o status de arquivo necessário para diagnóstico em um grupo.
|
||||
|
||||
* Opened: diagnosticar apenas arquivos abertos
|
||||
* Any: diagnosticar todos os arquivos
|
||||
* None: desabilitar este diagnóstico
|
||||
|
||||
`Fallback` significa que os diagnósticos deste grupo são controlados por `diagnostics.neededFileStatus` separadamente.
|
||||
Outras configurações sobrescreverão configurações individuais sem terminar com `!`.
|
||||
]]
|
||||
config.diagnostics.workspaceEvent =
|
||||
"Define quando acionar diagnósticos da workspace."
|
||||
config.diagnostics.workspaceEvent.OnChange =
|
||||
"Aciona diagnósticos da workspace quando o arquivo é modificado."
|
||||
config.diagnostics.workspaceEvent.OnSave =
|
||||
"Aciona diagnósticos da workspace quando o arquivo é salvo."
|
||||
config.diagnostics.workspaceEvent.None =
|
||||
"Desabilita diagnósticos da workspace."
|
||||
config.diagnostics.workspaceDelay =
|
||||
"Latência (milissegundos) para diagnósticos da workspace."
|
||||
config.diagnostics.workspaceRate =
|
||||
"Taxa de execução dos diagnósticos da workspace (%). Diminuir este valor reduz o uso de CPU, mas também reduz a velocidade dos diagnósticos. O diagnóstico do arquivo que você está editando sempre é feito em velocidade total e não é afetado por esta configuração."
|
||||
config.diagnostics.libraryFiles =
|
||||
"Como diagnosticar arquivos carregados via `Lua.workspace.library`."
|
||||
config.diagnostics.libraryFiles.Enable =
|
||||
"Sempre diagnosticar esses arquivos."
|
||||
config.diagnostics.libraryFiles.Opened =
|
||||
"Diagnosticar esses arquivos apenas quando estiverem abertos."
|
||||
config.diagnostics.libraryFiles.Disable =
|
||||
"Esses arquivos não são diagnosticados."
|
||||
config.diagnostics.ignoredFiles =
|
||||
"Como diagnosticar arquivos ignorados."
|
||||
config.diagnostics.ignoredFiles.Enable =
|
||||
"Sempre diagnosticar esses arquivos."
|
||||
config.diagnostics.ignoredFiles.Opened =
|
||||
"Diagnosticar esses arquivos apenas quando estiverem abertos."
|
||||
config.diagnostics.ignoredFiles.Disable =
|
||||
"Esses arquivos não são diagnosticados."
|
||||
config.diagnostics.disableScheme =
|
||||
'Não diagnosticar arquivos Lua que usam os seguintes schemes.'
|
||||
config.diagnostics.validScheme =
|
||||
'Habilita diagnósticos para arquivos Lua que usam os seguintes schemes.'
|
||||
config.diagnostics.unusedLocalExclude =
|
||||
'Não diagnosticar `unused-local` quando o nome da variável corresponder ao padrão a seguir.'
|
||||
config.workspace.ignoreDir =
|
||||
"Arquivos e diretórios ignorados (usa sintaxe `.gitignore`)."-- .. example.ignoreDir,
|
||||
config.workspace.ignoreSubmodules =
|
||||
"Ignorar submódulos."
|
||||
config.workspace.useGitIgnore =
|
||||
"Ignorar lista de arquivos em `.gitignore`."
|
||||
config.workspace.maxPreload =
|
||||
"Número máximo de arquivos pré-carregados."
|
||||
config.workspace.preloadFileSize =
|
||||
"Ignorar arquivos maiores que este valor (KB) ao pré-carregar."
|
||||
config.workspace.library =
|
||||
"Além da workspace atual, de quais diretórios carregar arquivos. Os arquivos nesses diretórios serão tratados como bibliotecas de código externas, e alguns recursos (como renomear campos) não modificarão esses arquivos."
|
||||
config.workspace.checkThirdParty =
|
||||
[[
|
||||
Detecção e adaptação automáticas de bibliotecas de terceiros; atualmente suportadas:
|
||||
|
||||
* OpenResty
|
||||
* Cocos4.0
|
||||
* LÖVE
|
||||
* LÖVR
|
||||
* skynet
|
||||
* Jass
|
||||
]]
|
||||
config.workspace.userThirdParty =
|
||||
'Adicione aqui caminhos de configuração de bibliotecas de terceiros privadas; consulte o [caminho de configuração](https://github.com/LuaLS/lua-language-server/tree/master/meta/3rd) embutido.'
|
||||
config.workspace.supportScheme =
|
||||
'Fornece language server para arquivos Lua dos seguintes schemes.'
|
||||
config.completion.enable =
|
||||
'Habilita autocompletar.'
|
||||
config.completion.callSnippet =
|
||||
'Mostra snippets de chamada de função.'
|
||||
config.completion.callSnippet.Disable =
|
||||
"Mostra apenas o `nome da função`."
|
||||
config.completion.callSnippet.Both =
|
||||
"Mostra o `nome da função` e o `trecho de chamada`."
|
||||
config.completion.callSnippet.Replace =
|
||||
"Mostra apenas o `trecho de chamada`."
|
||||
config.completion.keywordSnippet =
|
||||
'Mostra snippets de sintaxe de palavras-chave.'
|
||||
config.completion.keywordSnippet.Disable =
|
||||
"Mostra apenas a `palavra-chave`."
|
||||
config.completion.keywordSnippet.Both =
|
||||
"Mostra a `palavra-chave` e o `trecho de sintaxe`."
|
||||
config.completion.keywordSnippet.Replace =
|
||||
"Mostra apenas o `trecho de sintaxe`."
|
||||
config.completion.displayContext =
|
||||
"Pré-visualizar o trecho de código relevante da sugestão pode ajudar a entender seu uso. O número define quantas linhas são interceptadas no fragmento; definir como `0` desabilita este recurso."
|
||||
config.completion.workspaceWord =
|
||||
"Define se as palavras de contexto exibidas incluem conteúdo de outros arquivos da workspace."
|
||||
config.completion.showWord =
|
||||
"Mostrar palavras de contexto nas sugestões."
|
||||
config.completion.showWord.Enable =
|
||||
"Sempre mostrar palavras de contexto nas sugestões."
|
||||
config.completion.showWord.Fallback =
|
||||
"Mostrar palavras de contexto somente quando não houver sugestões baseadas em semântica."
|
||||
config.completion.showWord.Disable =
|
||||
"Não mostrar palavras de contexto."
|
||||
config.completion.autoRequire =
|
||||
"Quando a entrada se parece com um nome de arquivo, fazer `require` desse arquivo automaticamente."
|
||||
config.completion.maxSuggestCount =
|
||||
"Número máximo de campos analisados para autocompletar. Se um objeto tiver mais campos que esse limite, serão necessárias entradas mais específicas para que as sugestões apareçam."
|
||||
config.completion.showParams =
|
||||
"Mostrar parâmetros na lista de conclusão. Se a função tiver várias definições, elas serão exibidas separadamente."
|
||||
config.completion.requireSeparator =
|
||||
"Separador usado em `require`."
|
||||
config.completion.postfix =
|
||||
"Símbolo usado para acionar sugestões de pós-fixo."
|
||||
config.color.mode =
|
||||
"Modo de colorização."
|
||||
config.color.mode.Semantic =
|
||||
"Colorização semântica. Pode ser necessário definir `editor.semanticHighlighting.enabled` como `true`."
|
||||
config.color.mode.SemanticEnhanced =
|
||||
"Colorização semântica aprimorada; semelhante a `Semantic`, mas com análise extra (mais custosa computacionalmente)."
|
||||
config.color.mode.Grammar =
|
||||
"Colorização sintática."
|
||||
config.semantic.enable =
|
||||
"Habilita colorização semântica. Pode ser necessário definir `editor.semanticHighlighting.enabled` como `true`."
|
||||
config.semantic.variable =
|
||||
"Colorização semântica de variáveis/campos/parâmetros."
|
||||
config.semantic.annotation =
|
||||
"Colorização semântica de anotações de tipo."
|
||||
config.semantic.keyword =
|
||||
"Colorização semântica de palavras-chave/literais/operadores. Só habilite se seu editor não oferecer colorização sintática."
|
||||
config.signatureHelp.enable =
|
||||
"Habilitar ajuda de assinatura."
|
||||
config.hover.enable =
|
||||
"Habilitar hover."
|
||||
config.hover.viewString =
|
||||
"No hover, mostrar o conteúdo da string (apenas se o literal tiver caracteres de escape)."
|
||||
config.hover.viewStringMax =
|
||||
"Comprimento máximo da string exibida no hover."
|
||||
config.hover.viewNumber =
|
||||
"No hover, mostrar conteúdo numérico (apenas se o literal não for decimal)."
|
||||
config.hover.fieldInfer =
|
||||
"Ao inspecionar uma tabela no hover, inferir o tipo de cada campo; se o tempo acumulado atingir o limite (ms), os campos restantes serão ignorados."
|
||||
config.hover.previewFields =
|
||||
"Ao inspecionar uma tabela, limita o número máximo de campos pré-visualizados."
|
||||
config.hover.enumsLimit =
|
||||
"Quando um valor corresponde a vários tipos, limita quantos tipos são exibidos."
|
||||
config.hover.expandAlias =
|
||||
[[
|
||||
Definir se aliases devem ser expandidos. Por exemplo, `---@alias myType boolean|number` aparecerá como `boolean|number`; caso contrário aparecerá como `myType`.
|
||||
]]
|
||||
config.develop.enable =
|
||||
'Modo desenvolvedor. Não habilite; afeta o desempenho.'
|
||||
config.develop.debuggerPort =
|
||||
'Porta de escuta do depurador.'
|
||||
config.develop.debuggerWait =
|
||||
'Suspender antes de o depurador conectar.'
|
||||
config.intelliSense.searchDepth =
|
||||
'Define a profundidade de busca do IntelliSense. Aumentar melhora a precisão, mas reduz o desempenho. Ajuste conforme a tolerância da sua workspace.'
|
||||
config.intelliSense.fastGlobal =
|
||||
'Para completar globais e inspecionar `_G`, prioriza desempenho (ligeira perda de precisão de tipo); útil em projetos com muitas variáveis globais.'
|
||||
config.window.statusBar =
|
||||
'Mostrar status da extensão na barra de status.'
|
||||
config.window.progressBar =
|
||||
'Mostrar barra de progresso na barra de status.'
|
||||
config.hint.enable =
|
||||
'Habilitar inlay hints.'
|
||||
config.hint.paramType =
|
||||
'Mostrar dicas de tipo nos parâmetros da função.'
|
||||
config.hint.setType =
|
||||
'Mostrar dicas de tipo em atribuições.'
|
||||
config.hint.paramName =
|
||||
'Mostrar dicas com o nome do parâmetro na chamada de função.'
|
||||
config.hint.paramName.All =
|
||||
'Mostrar todos os tipos de parâmetros.'
|
||||
config.hint.paramName.Literal =
|
||||
'Mostrar apenas parâmetros de tipo literal.'
|
||||
config.hint.paramName.Disable =
|
||||
'Desativar dicas de nome de parâmetro.'
|
||||
config.hint.arrayIndex =
|
||||
'Mostrar dicas de índice de array ao construir uma tabela.'
|
||||
config.hint.arrayIndex.Enable =
|
||||
'Mostrar dicas em todas as tabelas.'
|
||||
config.hint.arrayIndex.Auto =
|
||||
'Mostrar dicas apenas quando a tabela tiver mais de 3 itens ou for uma tabela mista.'
|
||||
config.hint.arrayIndex.Disable =
|
||||
'Desativar dicas de índice de array.'
|
||||
config.hint.await =
|
||||
'Se a função chamada estiver marcada com `---@async`, sugerir `await` na chamada.'
|
||||
config.hint.awaitPropagate =
|
||||
'Habilita a propagação de `await`. Quando uma função chama outra marcada com `---@async`, ela será automaticamente marcada como `---@async`.'
|
||||
config.hint.semicolon =
|
||||
'Se não houver ponto e vírgula no fim da instrução, mostrar um ponto e vírgula virtual.'
|
||||
config.hint.semicolon.All =
|
||||
'Todas as instruções exibem ponto e vírgula virtual.'
|
||||
config.hint.semicolon.SameLine =
|
||||
'Quando duas instruções estiverem na mesma linha, mostrar um ponto e vírgula entre elas.'
|
||||
config.hint.semicolon.Disable =
|
||||
'Desativar pontos e vírgulas virtuais.'
|
||||
config.codeLens.enable =
|
||||
'Habilitar code lens.'
|
||||
config.format.enable =
|
||||
'Habilitar formatador de código.'
|
||||
config.format.defaultConfig =
|
||||
[[
|
||||
Configuração de formatação padrão; tem prioridade menor que o arquivo `.editorconfig` da workspace.
|
||||
Consulte a [documentação do formatador](https://github.com/CppCXY/EmmyLuaCodeStyle/tree/master/docs) para uso.
|
||||
]]
|
||||
config.spell.dict =
|
||||
'Palavras personalizadas para verificação ortográfica.'
|
||||
config.nameStyle.config =
|
||||
[[
|
||||
Configurações de estilo de nomes.
|
||||
Consulte a [documentação do formatador](https://github.com/CppCXY/EmmyLuaCodeStyle/tree/master/docs) para uso.
|
||||
]]
|
||||
config.telemetry.enable =
|
||||
[[
|
||||
Habilita telemetria para enviar informações do editor e logs de erro pela rede. Leia nossa política de privacidade [aqui](https://luals.github.io/privacy/#language-server).
|
||||
]]
|
||||
config.misc.parameters =
|
||||
'[Parâmetros de linha de comando](https://github.com/LuaLS/lua-telemetry-server/tree/master/method) ao iniciar o serviço de linguagem no VSCode.'
|
||||
config.misc.executablePath =
|
||||
'Especifica o caminho do executável no VSCode.'
|
||||
config.language.fixIndent =
|
||||
'(Somente VSCode) Corrige indentação automática incorreta, como quebras de linha dentro de uma string contendo a palavra "function".'
|
||||
config.language.completeAnnotation =
|
||||
'(Somente VSCode) Insere automaticamente "---@ " após uma quebra de linha seguinte a uma anotação.'
|
||||
config.type.castNumberToInteger =
|
||||
'Permitir atribuir o tipo `number` ao tipo `integer`.'
|
||||
config.type.weakUnionCheck =
|
||||
[[
|
||||
Quando um subtipo de uma união atende à condição, considera-se que a união inteira atende.
|
||||
|
||||
Quando esta opção for `false`, `number|boolean` não pode ser atribuído a `number`; com `true`, pode.
|
||||
]]
|
||||
config.type.weakNilCheck =
|
||||
[[
|
||||
Ao verificar um tipo união, ignora o `nil` presente nele.
|
||||
|
||||
Quando esta opção for `false`, `number|nil` não pode ser atribuído a `number`; com `true`, pode.
|
||||
]]
|
||||
config.type.inferParamType =
|
||||
[[
|
||||
Quando o parâmetro não tiver anotação, inferir o tipo a partir dos argumentos de chamada.
|
||||
|
||||
Quando esta opção for `false`, o tipo do parâmetro será `any` se não houver anotação.
|
||||
]]
|
||||
config.type.checkTableShape =
|
||||
[[
|
||||
Verificação rigorosa do formato das tabelas.
|
||||
]]
|
||||
config.type.inferTableSize =
|
||||
'Número máximo de campos de tabela analisados durante a inferência de tipo.'
|
||||
config.doc.privateName =
|
||||
'Tratar nomes de campos específicos como privados; ex.: `m_*` significa que `XXX.m_id` e `XXX.m_type` são privados e só podem ser acessados na classe onde foram definidos.'
|
||||
config.doc.protectedName =
|
||||
'Tratar nomes de campos específicos como protegidos; ex.: `m_*` significa que `XXX.m_id` e `XXX.m_type` são protegidos e só podem ser acessados na classe onde foram definidos e em subclasses.'
|
||||
config.doc.packageName =
|
||||
'Tratar nomes de campos específicos como de pacote; ex.: `m_*` significa que `XXX.m_id` e `XXX.m_type` são de pacote e só podem ser acessados no arquivo onde foram definidos.'
|
||||
config.doc.regengine =
|
||||
'Mecanismo de expressão regular usado para corresponder nomes de escopo de documentação.'
|
||||
config.doc.regengine.glob =
|
||||
'Sintaxe de padrão leve padrão.'
|
||||
config.doc.regengine.lua =
|
||||
'Expressões regulares completas no estilo Lua.'
|
||||
config.docScriptPath =
|
||||
'Mecanismo de expressão regular usado para corresponder nomes de escopo de documentação.'
|
||||
config.diagnostics['unused-local'] =
|
||||
'Variável local não utilizada'
|
||||
config.diagnostics['unused-function'] =
|
||||
'Função não utilizada'
|
||||
config.diagnostics['undefined-global'] =
|
||||
'Variável global não definida'
|
||||
config.diagnostics['global-in-nil-env'] =
|
||||
'Não é possível usar variáveis globais (`_ENV` foi definido como `nil`)'
|
||||
config.diagnostics['unused-label'] =
|
||||
'Rótulo não utilizado'
|
||||
config.diagnostics['unused-vararg'] =
|
||||
'Parâmetro vararg não utilizado'
|
||||
config.diagnostics['trailing-space'] =
|
||||
'Espaços à direita'
|
||||
config.diagnostics['redefined-local'] =
|
||||
'Variável local redefinida'
|
||||
config.diagnostics['newline-call'] =
|
||||
'Nova linha iniciando com `(` é analisada como chamada da linha anterior'
|
||||
config.diagnostics['newfield-call'] =
|
||||
'Em uma tabela literal, faltou um separador entre duas linhas; foi interpretado como uma operação de índice'
|
||||
config.diagnostics['redundant-parameter'] =
|
||||
'Chamada de função com parâmetros em excesso'
|
||||
config.diagnostics['ambiguity-1'] =
|
||||
'Ambiguidade de precedência, por exemplo `num or 0 + 1`; supõe-se que o esperado seja `(num or 0) + 1`'
|
||||
config.diagnostics['lowercase-global'] =
|
||||
'Definição de variável global com inicial minúscula'
|
||||
config.diagnostics['undefined-env-child'] =
|
||||
'`_ENV` foi definido como nova tabela literal, mas a variável global acessada não está nela'
|
||||
config.diagnostics['duplicate-index'] =
|
||||
'Índice duplicado em tabela literal'
|
||||
config.diagnostics['empty-block'] =
|
||||
'Bloco vazio'
|
||||
config.diagnostics['redundant-value'] =
|
||||
'Em uma atribuição, há mais valores que variáveis-alvo'
|
||||
config.diagnostics['assign-type-mismatch'] =
|
||||
'Habilita diagnóstico para atribuições em que o tipo do valor não corresponde ao tipo da variável alvo.'
|
||||
config.diagnostics['await-in-sync'] =
|
||||
'Habilita diagnóstico para chamadas de funções assíncronas dentro de uma função síncrona.'
|
||||
config.diagnostics['cast-local-type'] =
|
||||
'Habilita diagnóstico para coerções de variáveis locais em que o tipo alvo não corresponde ao tipo definido.'
|
||||
config.diagnostics['cast-type-mismatch'] =
|
||||
'Habilita diagnóstico para coerções em que o tipo alvo não corresponde ao tipo inicial.'
|
||||
config.diagnostics['circular-doc-class'] =
|
||||
'Habilita diagnóstico para classes que herdam entre si, formando relação circular.'
|
||||
config.diagnostics['close-non-object'] =
|
||||
'Habilita diagnóstico para tentativas de fechar uma variável que não é objeto.'
|
||||
config.diagnostics['code-after-break'] =
|
||||
'Habilita diagnóstico para código após um `break` em um loop.'
|
||||
config.diagnostics['codestyle-check'] =
|
||||
'Habilita diagnóstico para linhas que violam o estilo de código.'
|
||||
config.diagnostics['count-down-loop'] =
|
||||
'Habilita diagnóstico para laços `for` decrescentes que nunca atingem o limite porque são incrementados.'
|
||||
config.diagnostics['deprecated'] =
|
||||
'Habilita diagnóstico para APIs obsoletas.'
|
||||
config.diagnostics['different-requires'] =
|
||||
'Habilita diagnóstico para arquivos exigidos por dois caminhos diferentes.'
|
||||
config.diagnostics['discard-returns'] =
|
||||
'Habilita diagnóstico para chamadas de funções anotadas com `---@nodiscard` quando os retornos são ignorados.'
|
||||
config.diagnostics['doc-field-no-class'] =
|
||||
'Habilita diagnóstico para anotações de campo sem anotação de classe correspondente.'
|
||||
config.diagnostics['duplicate-doc-alias'] =
|
||||
'Habilita diagnóstico para nome de alias anotado duplicado.'
|
||||
config.diagnostics['duplicate-doc-field'] =
|
||||
'Habilita diagnóstico para nome de campo anotado duplicado.'
|
||||
config.diagnostics['duplicate-doc-param'] =
|
||||
'Habilita diagnóstico para nome de parâmetro anotado duplicado.'
|
||||
config.diagnostics['duplicate-set-field'] =
|
||||
'Habilita diagnóstico para definir o mesmo campo em uma classe mais de uma vez.'
|
||||
config.diagnostics['incomplete-signature-doc'] =
|
||||
'Anotações @param ou @return incompletas para funções.'
|
||||
config.diagnostics['invisible'] =
|
||||
'Habilita diagnóstico para acessos a campos invisíveis.'
|
||||
config.diagnostics['missing-global-doc'] =
|
||||
'Faltam anotações para globais! Funções globais devem ter comentário e anotações para todos os parâmetros e retornos.'
|
||||
config.diagnostics['missing-local-export-doc'] =
|
||||
'Faltam anotações para locais exportados! Funções locais exportadas devem ter comentário e anotações para todos os parâmetros e retornos.'
|
||||
config.diagnostics['missing-parameter'] =
|
||||
'Habilita diagnóstico para chamadas de função com menos argumentos que os parâmetros anotados.'
|
||||
config.diagnostics['missing-return'] =
|
||||
'Habilita diagnóstico para funções com anotação de retorno mas sem instrução return.'
|
||||
config.diagnostics['missing-return-value'] =
|
||||
'Habilita diagnóstico para retornos sem valores embora a função declare valores de retorno.'
|
||||
config.diagnostics['need-check-nil'] =
|
||||
'Habilita diagnóstico para uso de variável após ela receber `nil` ou valor opcional.'
|
||||
config.diagnostics['unnecessary-assert'] =
|
||||
'Habilita diagnóstico para asserts redundantes em valores verdadeiros.'
|
||||
config.diagnostics['no-unknown'] =
|
||||
'Habilita diagnóstico para casos em que o tipo não pode ser inferido.'
|
||||
config.diagnostics['not-yieldable'] =
|
||||
'Habilita diagnóstico para chamadas de `coroutine.yield()` quando não permitido.'
|
||||
config.diagnostics['param-type-mismatch'] =
|
||||
'Habilita diagnóstico para chamadas onde o tipo do parâmetro fornecido não corresponde à definição anotada.'
|
||||
config.diagnostics['redundant-return'] =
|
||||
'Habilita diagnóstico para retornos desnecessários porque a função já terminaria.'
|
||||
config.diagnostics['redundant-return-value']=
|
||||
'Habilita diagnóstico para retornos que entregam valor extra não especificado na anotação.'
|
||||
config.diagnostics['return-type-mismatch'] =
|
||||
'Habilita diagnóstico para retornos cujo tipo não corresponde ao tipo declarado.'
|
||||
config.diagnostics['spell-check'] =
|
||||
'Habilita diagnóstico para erros ortográficos em strings.'
|
||||
config.diagnostics['name-style-check'] =
|
||||
'Habilita diagnóstico para estilo de nomes.'
|
||||
config.diagnostics['unbalanced-assignments']=
|
||||
'Habilita diagnóstico em múltiplas atribuições se nem todas as variáveis recebem valor (ex.: `local x,y = 1`).'
|
||||
config.diagnostics['undefined-doc-class'] =
|
||||
'Habilita diagnóstico para anotações de classe que fazem referência a classe indefinida.'
|
||||
config.diagnostics['undefined-doc-name'] =
|
||||
'Habilita diagnóstico para anotações de tipo que referenciam tipo ou alias indefinido.'
|
||||
config.diagnostics['undefined-doc-param'] =
|
||||
'Habilita diagnóstico para anotações de parâmetro sem declaração correspondente na função.'
|
||||
config.diagnostics['undefined-field'] =
|
||||
'Habilita diagnóstico para leitura de campo indefinido de uma variável.'
|
||||
config.diagnostics['unknown-cast-variable'] =
|
||||
'Habilita diagnóstico para coerções de variáveis indefinidas.'
|
||||
config.diagnostics['unknown-diag-code'] =
|
||||
'Habilita diagnóstico quando um código de diagnóstico desconhecido é informado.'
|
||||
config.diagnostics['unknown-operator'] =
|
||||
'Habilita diagnóstico para operadores desconhecidos.'
|
||||
config.diagnostics['unreachable-code'] =
|
||||
'Habilita diagnóstico para código inalcançável.'
|
||||
config.diagnostics['global-element'] =
|
||||
'Habilita diagnóstico para avisar sobre elementos globais.'
|
||||
config.typeFormat.config =
|
||||
'Configura o comportamento de formatação enquanto digita código Lua.'
|
||||
config.typeFormat.config.auto_complete_end =
|
||||
'Controla se `end` é completado automaticamente em posições adequadas.'
|
||||
config.typeFormat.config.auto_complete_table_sep =
|
||||
'Controla se um separador é adicionado automaticamente ao final de uma declaração de tabela.'
|
||||
config.typeFormat.config.format_line =
|
||||
'Controla se uma linha deve ser formatada.'
|
||||
|
||||
command.exportDocument =
|
||||
'Lua: Exportar Documento ...'
|
||||
command.addon_manager.open =
|
||||
'Lua: Abrir Gerenciador de Addon ...'
|
||||
command.reloadFFIMeta =
|
||||
'Lua: Recarregar metadados luajit ffi'
|
||||
command.startServer =
|
||||
'Lua: Reiniciar Language Server'
|
||||
command.stopServer =
|
||||
'Lua: Parar Language Server'
|
||||
Reference in New Issue
Block a user