tutorial [MTABRASIL] Como Criar Script Para Multi Theft Auto [Tutorial 2012+Official Site]

[mestregd1 3]

Olá Galerinha Sou o MestreGD1~

E Vou Ensinar a como fazer seu script De mta.

que podem ver o trecho é longo. mais se quér

realmente aprender você terar que saber Muito para chegar aos scripts..

 

1 - Introdução

 

Lua é uma linguagem de programação de extensão projetada para suportar programação procedural geral com instalações de descrição dos dados. Ele também oferece um bom suporte para programação orientada a objetos, programação funcional e programação orientada a dados. Lua se destina a ser usado como uma poderosa linguagem de script leve e para qualquer programa que precisa de um. Lua é implementada como uma biblioteca, escrito em C limpo (isto é, no subconjunto comum de ANSI C e C + +).

Sendo uma linguagem de extensão, Lua não tem noção de um programa "principal": ele só funciona incorporado em um cliente anfitrião, chamado o programa de incorporação ou simplesmente o anfitrião. Esse programa hospedeiro pode invocar funções para executar um pedaço de código Lua, pode escrever e ler variáveis ​​Lua e pode registrar funções C para serem chamadas pelo código Lua. Através do uso de funções C, Lua pode ser estendida para lidar com uma vasta gama de domínios diferentes, criando assim as linguagens de programação personalizadas que compartilham uma estrutura sintática. A distribuição Lua inclui um programa de acolhimento de amostra chamado lua, que usa a biblioteca de Lua para oferecer uma solução completa, independente interpretador Lua.

Lua é software livre, e é fornecido como de costume, sem garantias, tal como indicado na sua licença. A implementação descrita neste manual está disponível no site web oficial de Lua, The Programming Language Lua.

Como qualquer outro manual de referência, este documento é seca em alguns lugares. Para uma discussão sobre as decisões por trás do projeto de Lua, ver os artigos técnicos disponíveis no site da Lua na web. Para uma introdução detalhada à programação em Lua, veja o livro de Roberto, Programação em Lua (segunda edição). 2 - A Língua

Esta seção descreve o léxico, a sintaxe ea semântica da Lua. Em outras palavras, esta seção descreve quais símbolos são válidos, como eles podem ser combinados, e quais as suas combinações significam.

As construções da linguagem serão explicadas usando a notação BNF estendida usual, em que {a} significa 0 ou mais um, e [a] significa um opcional a. Não-terminais são mostrados como não-terminal, palavras-chave são mostradas como kword e outros símbolos terminais são mostrados como `= '. A sintaxe completa de Lua pode ser encontrada em § 8 no final deste manual. 2.1 - Convenções lexical

Nomes (também chamados de identificadores) na Lua pode ser qualquer seqüência de letras, dígitos e sublinhados que não começam com um dígito. Isto coincide com a definição de nomes na maioria das línguas. (A definição de letras depende da localidade atual: qualquer caractere considerado alfabético pelo idioma corrente pode ser usado como um identificador.) Identificadores são usados ​​para nomear variáveis ​​e campos de tabelas.

As seguintes palavras estão reservados e não podem ser usadas como nomes:

 

e quebra de fazer mais elseif

acabar com falsa para a função se

no local ou nulo não

repetir, em seguida, retornar verdadeiro até enquanto

Lua é uma linguagem case-sensitive, e é uma palavra reservada, mas And e AND são dois nomes válidos diferentes. Como convenção, os nomes que começam com um. Sublinhado seguido por letras maiúsculas (como _VERSION) são reservados para variáveis ​​globais internas usadas por Lua.

As seguintes cadeias denotam outros símbolos:

+ - * /% ^ #

== ~ = <=> = <> =

() {} []

;:,. .. ...

Strings literais podem ser delimitadas por aspas simples ou aspas dupla, e pode conter o seguinte C-como seqüências de escape: '\ a' (campainha), '\ b' (backspace), '\ f' (**** feed), '\ '(newline),' n \ r '(retorno de carro),' \ t '(tabulação horizontal),' \ v '(tabulação vertical),' \ \ '(barra invertida),' \ "'(aspas [duplo quote]), e '\'' (apóstrofe [apóstrofo]). Além disso, uma barra invertida seguida por uma linha real resulta em uma nova linha na string. Um caractere em uma string também pode ser especificado pelo seu valor numérico usando a fuga seqüência \ ddd, onde ddd é uma seqüência de até três dígitos decimais. (Note que se uma fuga numérica deve ser seguido por um dígito, deve ser exatamente três dígitos). Cordas em Lua pode conter qualquer de 8 bits valor, incluindo zeros, que podem ser especificados como '\ 0'.

Strings literais também podem ser definidas usando um formato longo delimitado por colchetes longos. Nós definimos uma abertura de colchete longo de nível n como um abre colchete seguido por n sinais de igual seguido por outro abre colchete. Assim, um suporte de abertura longo de nível 0 é escrito como [[, um suporte de abertura longo de nível 1 é escrito como [= [, e assim por diante. Um suporte de fechar longa é definida de forma semelhante, por exemplo, um suporte de fechamento longo de nível 4 é escrito como] ====]. Uma seqüência de caracteres longa começa com uma abertura de colchete longo de qualquer nível e termina no primeiro fechamento de colchete longo do mesmo nível. Literais expressos desta forma podem ser executados por várias linhas, não interpretam nenhuma seqüência de escape e ignoram colchetes longos de qualquer outro nível. Eles podem conter nada além de um colchete de fechamento do nível adequado.

Por conveniência, quando a abertura de colchete longo é imediatamente seguido por uma nova linha, a linha não é incluída na cadeia. Como um exemplo, em um sistema usando ASCII (em que 'a' é codificado como 97, é codificado como uma nova linha 10, e '1 'é codificado como 49), os cinco cadeias literais abaixo denotam a mesma cadeia:

 

a = 'alo \ n123 "'

a = "alo \ n123 \" "

a = '\ 97lo \ 10 \ 04923 "'

a = [[alo

123 "]]

a = [== [

alo

123 "] ==]

Uma constante numérica pode ser escrita com uma parte decimal opcional e um expoente decimal opcional. Lua também aceita constantes hexadecimais inteiras, prefixando-os com 0x. Exemplos de constantes numéricas válidas são

 

3

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

Um comentário começa com um hífen duplo (-) em qualquer lugar fora de uma string. Se o texto imediatamente depois - não é uma abertura de colchete longo, o comentário é um comentário curto, ou seja, até o fim da linha. Caso contrário, é um comentário longo, que vai até o colchete de fechamento correspondente longo. Comentários longos são freqüentemente usados ​​para desabilitar código temporariamente. 2.2 - Os valores e tipos de

Lua é uma linguagem dinamicamente tipada. Isto significa que as variáveis ​​não têm tipos e valores de apenas fazer. Não há definições de tipo na linguagem. Todos os valores carregam o seu próprio tipo.

Todos os valores em Lua são valores de primeira classe. Isto significa que todos os valores podem ser armazenados em variáveis, passados ​​como argumentos para outras funções, e voltou como resultados.

Existem oito tipos básicos em Lua: nil, boolean, número, string, função, userdata, thread e mesa. Nil é o tipo de valor nil, cuja propriedade principal é para ser diferente de qualquer outro valor, que normalmente representa a ausência de um valor útil. Booleana é o tipo dos valores falsos e verdadeiro. Tanto nil como false tornam uma condição falsa; qualquer outro valor a torna verdadeira. Número representa real (precisão dupla de ponto flutuante) números. (É fácil construir interpretadores Lua que usem outra representação interna de números, tais como precisão simples de ponto flutuante ou inteiros longos; ver luaconf.h arquivo). String representa arrays de caracteres. Lua é 8-bit limpo: strings podem conter qualquer caractere de 8 bits, incluindo zeros ('\ 0') (ver § 2.1).

Lua pode chamar (e manipular) funções escritas em Lua e funções escritas em C (ver § 2.5.8).

O tipo userdata permite que dados arbitrários C para serem armazenados em variáveis ​​Lua.. Este tipo corresponde a um bloco de memória e não tem operações pré-definidas na Lua, exceto atribuição e teste de identidade. No entanto, usando metatables, o programador pode definir operações para valores userdata (ver § 2.8). Valores userdata não podem ser criados ou modificados em Lua, somente através da API C. Isto garante a integridade dos dados que pertencem ao programa hospedeiro.

O tipo thread representa de execução independentes e é usado para implementar co-rotinas (ver § 2.11). Não confunda tópicos Lua com sistema operacional tópicos. Lua suporte co-rotinas em todos os sistemas, mesmo aqueles que não suportam threads.

O tipo table implementa arrays associativos, isto é, matrizes que podem ser indexados não apenas com números, mas com qualquer valor (exceto nil). As tabelas podem ser heterogénea, isto é, eles podem conter valores de todos os tipos (excepto nil). As tabelas são o mecanismo de estruturação de dados único em Lua, pois eles podem ser usados ​​para representar arrays comuns, tabelas de símbolos, conjuntos, registros, grafos, árvores, etc Para representar registros, Lua usa o nome do campo como um índice. A linguagem suporta esta representação oferecendo a.name como um açúcar sintático para a ["name"]. Existem várias maneiras convenientes para criar tabelas em Lua (ver § 2.5.7).

Tal como os índices, o valor de um campo tabela pode ser de qualquer tipo (excepto nil). Em particular, porque as funções são valores de primeira classe, campos de tabela podem conter funções. Assim, as tabelas podem também possuir metódos (ver § 2.5.9).

Tabelas, funções, segmentos e valores (completo) userdata são objetos: variáveis ​​não contêm realmente estes valores, somente referências para eles. Atribuição, passagem de parâmetro, a função e retorna sempre lidam com referências para tais valores; estas operações não implicam qualquer tipo de cópia.

A função type retorna uma string descrevendo o tipo de um determinado valor. 2.2.1 - Coerção

Lua provê conversão automática entre string e valores numéricos em tempo de execução. Qualquer operação aritmética aplicada a uma cadeia de caracteres tenta converter esta string para um número, seguindo as regras de conversão usuais. Por outro lado, sempre que um número é usado onde uma cadeia de caracteres é esperado, o número é convertido para uma cadeia, em um formato razoável. Para um controle completo sobre como números são convertidos para strings, use a função format da biblioteca string (ver string.format). 2.3 - Variáveis

Variáveis ​​são locais que armazenam valores. Existem três tipos de variáveis ​​em Lua: variáveis ​​globais, variáveis ​​locais e campos de tabelas.

Um nome simples pode denotar uma variável global ou uma variável local (ou parâmetro formal de uma função, que é um tipo particular de variável local):

var :: = Nome

Nome denota identificadores, tal como definido no § 2,1.

Qualquer variável é assumido para ser global, a menos que explicitamente declarado como um local (ver § 2.4.7). As variáveis ​​locais possuem escopo léxico: variáveis ​​locais podem ser livremente acessadas por funções definidas dentro do seu escopo (ver § 2.6).

Antes da primeira atribuição a uma variável, seu valor é nulo.

Colchetes são usados ​​para indexar uma tabela:

var :: = expprefixo `['exp`]'

O significado de acessos a variáveis ​​globais e campos de tabela pode ser alterada via metatabelas. Um acesso a uma t indexada variável é equivalente a uma gettable_event chamada (t, i). (Veja § 2.8 para uma descrição completa da função gettable_event. Esta função não é definida nem pode ser chamada em Lua.. Utilizamos aqui somente para fins didáticos.)

O var.Name sintaxe é apenas um açúcar sintático para var ["Nome"]:

var :: = expprefixo `'. Nome

Todas as variáveis ​​globais como campos em tabelas Lua comuns, chamadas de tabelas de ambiente ou simplesmente de ambientes (ver § 2.9). Cada função tem sua própria referência a um ambiente, de modo que todas as variáveis ​​globais nesta função irão se referir a esta tabela de ambiente. Quando uma função é criada, ela herda o ambiente a partir da função que o criou. Para obter a tabela de ambiente de uma função Lua, você chama getfenv. Para substituí-lo, você chama setfenv. (Você só pode manipular o ambiente de funções C através da biblioteca de depuração; (ver § 5.9).)

Um acesso a uma x variável global é equivalente a _env.x, que por sua vez é equivalente para

 

gettable_event (_env, "x")

onde _env é o ambiente da função em execução. (Veja § 2.8 para uma descrição completa da função gettable_event. Esta função não é definida nem pode ser chamada em Lua.. Da mesma forma, a variável _env não está definido na Lua. Nós os usamos aqui somente para fins didáticos.) 2.4 - Demonstrações

Lua oferece um conjunto quase convencional de declarações, semelhantes às de Pascal ou C. Este conjunto inclui atribuições, estruturas de controle, chamadas de função e declarações de variáveis. 2.4.1 - Pedaços

A unidade de execução de Lua é chamado um pedaço. Um trecho é simplesmente uma seqüência de comandos, que são executados seqüencialmente. Cada comando pode opcionalmente ser seguido por um ponto e vírgula:

trecho :: = {comando [`; ']}

Não há declarações vazias e assim ';;' não é legal.

Lua trata um trecho como o corpo de uma função anônima com um número variável de argumentos (ver § 2.5.9). Desta forma, trechos pode definir variáveis ​​locais, receber argumentos e valores de retorno.

Um pedaço pode ser armazenado em um arquivo ou em uma string dentro do programa hospedeiro. Para executar um pedaço, Lua primeiro pré-compila o pedaço em instruções para uma máquina virtual, e, em seguida, ele executa o código compilado com um interpretador para a máquina virtual.

Pedaços também pode ser pré-compilados em forma binária, ver Luac programa para obter mais detalhes. Programas em formas originais e compilados são intercambiáveis; Lua detecta automaticamente o tipo de arquivo e age em conformidade. 2.4.2 - Blocos

Um bloco é uma lista de declarações; sintaticamente, um bloco é o mesmo que um trecho:

bloco :: = trecho

Um bloco pode ser explicitamente delimitado para produzir um único comando:

comando :: = do bloco end

Blocos explícitos são úteis para controlar o escopo de declarações de variáveis. Blocos explícitos são também por vezes utilizado para adicionar um comando return ou break no meio de outro bloco (ver § 2.4.4). 2.4.3 - Atribuição

Lua permite atribuições múltiplas. Portanto, a sintaxe para atribuição define uma lista de variáveis ​​no lado esquerdo e uma lista de expressões no lado direito. Os elementos em ambas as listas são separados por vírgulas:

comando :: = varlist `= explist ' varlist :: = var {`, 'var} explist :: exp = {`, ​​exp '}

As expressões são discutidos em § 2,5.

Antes da atribuição, a lista de valores é ajustado para o comprimento da lista de variáveis. Se houver mais valores do que necessários, os valores em excesso são descartados. Se há menos valores do que o necessário, a lista é estendida com tantos nil é tão necessário. Se a lista de expressões termina com uma chamada de função, então todos os valores retornados por esta chamada entram na lista de valores, antes do ajuste (exceto quando a chamada é colocada entre parênteses, ver § 2.5).

A instrução de atribuição primeiro avalia todas as suas expressões e só então são as atribuições realizadas. Assim, o código

 

i = 3

i, a = i +1, 20

define a [3] a 20, sem afetar a [4] porque o i em um é avaliado (a 3) antes de ser atribuído 4. Do mesmo modo, a linha

 

x, y = y, x

troca os valores de x e y, e

 

x, y, z = y, z, x

ciclicamente permuta os valores de x, y, z.

O significado de atribuições para variáveis ​​globais e campos de tabela pode ser alterada via metatabelas. Uma atribuição para uma variável indexada t = val é equivalente a settable_event (t, i, val). (Veja § 2.8 para uma descrição completa da função settable_event. Esta função não é definida nem pode ser chamada em Lua.. Utilizamos aqui somente para fins didáticos.)

Uma atribuição para uma variável global x = val é equivalente à atribuição _env.x = val, que por sua vez é equivalente para

 

settable_event (_env, "x", val)

onde _env é o ambiente da função em execução. (A variável _env não está definido na Lua. Utilizamos aqui somente para fins didáticos.) 2.4.4 - Estruturas de Controle

As estruturas de controle if, while e repeat possuem o significado usual ea sintaxe familiar:

comando :: = final do bloco, enquanto exp fazer bloco de comando :: = repetir até exp comando :: = exp se então o bloco {exp elseif então bloco} [bloco else] end

Lua também tem uma instrução, em dois sabores (ver § 2.4.5).

A expressão da condição de uma estrutura de controle pode retornar qualquer valor. False e nil são considerados falsos. Todos os valores diferentes de nil e false são consideradas verdadeiras (em particular, o número 0 ea cadeia vazia também são verdadeiros).

No laço repeat-until, o bloco mais interno não termina até que a palavra-chave, mas só depois de a condição. Assim, a condição pode fazer referência a variáveis ​​locais declaradas dentro do bloco do laço.

O comando return é usado para retornar valores de uma função ou um trecho (que é apenas uma função). Funções e trechos podem retornar mais de um valor, e assim a sintaxe para a instrução de retorno é

comando :: = retorno [explist]

A instrução break é usada para terminar a execução de um tempo, repito, ou para o laço, pulando para a próxima instrução após o loop:

comando :: = pausa

Um break termina o loop mais interno.

O retorno e instruções break só pode ser escrito como a última declaração de um bloco. Se for realmente necessário para voltar ou quebrar no meio de um bloco, em seguida, um bloco interno explícito pode ser utilizado, como nas expressões idiomáticas do return end e do break end, porque agora retornar e quebrar são os últimos comandos em seu (interior ) blocos. 2.4.5 - Para a declaração de

A instrução tem duas formas: uma numérica e outra genérica.

O laço for numérico repete um bloco de código enquanto uma variável de controle é executado através de uma progressão aritmética. Ele tem a seguinte sintaxe:

comando :: = for nome `= 'exp`,' exp [`, exp '] final do bloco do

O bloco é repetido para nome começando com o valor do primeiro exp, até que ela passa o segundo exp por etapas do terceiro exp. Mais precisamente, uma declaração de como

 

para v = e1, e2, e3 do final do bloco

é equivalente ao código:

 

fazer

var local, limite, passo = tonumber (e1), tonumber (e2), tonumber (e3)

se não for (var limite e passo), em seguida, fim de erro ()

while (step> 0 e var <= limite) ou (passo <= 0 e var> = limite) fazer

local, v = var

bloquear

var = var + passo

final

final

Observe o seguinte:

 

Todas as três expressões de controle são avaliados apenas uma vez, antes do laço começar. Todos eles devem resultar em números.

var, limite, passo e são variáveis ​​invisíveis. Os nomes aqui apresentados são somente para fins didáticos.

Se a expressão terceiro (o passo) está ausente, então um passo de 1 é usado.

Você pode usar break para sair de um loop.

O v variável do laço é local para o loop, você não pode usar o seu valor após o término do for ou está quebrado. Se você precisa deste valor, atribuí-la a outra variável antes de interromper ou sair do loop.

O genérico para instrução funciona sobre as funções, iteradores chamados. Em cada iteração, a função iterator é chamado para produzir um novo valor, parando quando este novo valor é nulo. O laço for genérico tem a seguinte sintaxe:

comando :: = bloco para namelist em explist fazer final namelist :: = Nome {`, nome '}

Uma declaração de como

 

para VAR_1, · · ·, var_n em explist fazer final do bloco

é equivalente ao código:

 

fazer

f local, s, var = explist

enquanto verdade fazer

VAR_1 locais, · · ·, var_n = f (s, var)

var = VAR_1

se var == nil em seguida, quebrar final

bloquear

final

final

Observe o seguinte:

 

explist é avaliada apenas uma vez. Seus resultados são uma função iterator, um estado, e um valor inicial para a primeira variável iteradora.

F, S, e var são variáveis ​​invisíveis. Os nomes são aqui somente para fins didáticos.

Você pode usar break para sair de um loop.

As variáveis ​​var_i alça, são locais ao laço; você não pode usar seus valores após o término do for. Se você precisa estes valores, em seguida, atribuí-los a outras variáveis ​​antes de interromper ou sair do loop.

2.4.6 - As chamadas funções como Demonstrações

Para permitir que os possíveis efeitos colaterais, chamadas de funções podem ser executadas como comandos:

comando :: = chamadadefuncao

Neste caso, todos os valores retornados são deitados fora. Chamadas de função são explicadas em § 2.5.8. 2.4.7 - Declarações locais

As variáveis ​​locais podem ser declaradas em qualquer lugar dentro de um bloco. A declaração pode incluir uma atribuição inicial:

comando :: = namelist local [`= explist ']

Se estiver presente uma atribuição inicial, tem a mesma semântica de uma atribuição múltipla (ver § 2.4.3). Caso contrário, todas as variáveis ​​são inicializadas com nil.

Um trecho também é um bloco (ver § 2.4.1), e portanto variáveis ​​locais podem ser declaradas em um trecho fora de qualquer bloco explícito. O âmbito de tais variáveis ​​locais estende-se até ao final do pedaço.

As regras de visibilidade para as variáveis ​​locais são explicadas em § 2.6. 2.5 - Expressões

As expressões básicas em Lua são as seguintes:

exp :: = expprefixo exp :: = nil | false | true exp :: = Número exp :: String = exp :: = function exp :: = tableconstructor exp :: = `... ' exp :: = exp exp binop exp :: = exp UNOP expprefixo :: = var | chamadadefuncao | `('exp') '

Números e cadeias literais são explicados em § 2.1; variáveis ​​são explicadas em § 2.3; definições de funções são explicadas em § 2.5.9; chamadas funções são explicadas em § 2.5.8; construtores de tabelas são explicadas em § 2.5.7. Expressões vararg, denotadas por três pontos ('...'), só pode ser usado quando diretamente dentro de uma função vararg, pois eles são explicadas em § 2.5.9.

Operadores binários compreendem operadores aritméticos (ver § 2.5.1), operadores relacionais (ver § 2.5.2), operadores lógicos (ver § 2.5.3), eo operador de concatenação (ver § 2.5.4). Operadores unários compreendem o menos unário (ver § 2.5.1), não o unário (ver § 2.5.3), eo operador de tamanho unário (ver § 2.5.5).

Tanto chamadas de funções e expressões vararg podem resultar em valores múltiplos. Se uma expressão é usada como uma declaração (possível apenas para chamadas de função (ver § 2.4.6)), então a sua lista de retorno é ajustada para zero elementos, descartando portanto todos os valores retornados. Se uma expressão é usada como o elemento (ou único) última de uma lista de expressões, então nenhum ajuste é feito (a menos que a chamada é colocada entre parênteses). Em todos os outros contextos, Lua ajusta a lista de resultado para um elemento, descartando todos os valores exceto o primeiro.

Aqui estão alguns exemplos:

f () - ajustado para 0 resultados

g (f (), x) - f () é ajustado para 1 resultado

g (x, f ()) - g recebe x mais todos os resultados de f ()

a, b, c = f (), x - f () é ajustado para um resultado (c recebe nil)

a, b = ... - A recebe o parâmetro vararg primeiro, b fica

- O segundo (tanto a como b pode obter nil se há

- Não é parâmetro correspondente na lista)

 

a, b, c = x, f () - f () é ajustado para 2 resultados

a, b, c = f () - f () é ajustado para 3 resultados

f return () - retorna todos os resultados de f ()

retornar ... - Retorna todos os parâmetros recebidos vararg

retorno x, y, f () - retorna x, y, e todos os resultados de f ()

{F ()} - cria uma lista com todos os resultados de f ()

{...} - Cria uma lista com todos os parâmetros vararg

{F (), nil} - f () é ajustado para um resultado

 

Qualquer expressão entre parênteses sempre resulta em apenas um valor. Assim, (f (x, y, z)) é sempre um valor único, mesmo que f retorne vários valores. (O valor de (f (x, y, z)) é o primeiro valor retornado por f ou nil se f não retornar quaisquer valores.) 2.5.1 - Operadores Aritméticos

Lua provê os operadores aritméticos usuais: o binário + (adição), - (subtração), * (multiplicação), / (divisão),% (módulo) e ^ (exponenciação), e operador unário - (negação). Se os operandos são números ou seqüências que podem ser convertidos em números (ver § 2.2.1), então todas as operações têm o significado usual. Exponenciação funciona para qualquer expoente. Por exemplo, x ^ (-0,5) calcula o inverso da raiz quadrada de x. Modulo é definido como

a% b == a - Math.floor (a / b) * b

Ou seja, é o resto de uma divisão que arredonda o quociente direção a menos infinito. 2.5.2 - Operadores Relacionais

Os operadores relacionais em Lua são

 

== ~ = <> <=> =

Estes operadores sempre resultar em falso ou verdadeiro.

Igualdade (==) compara o primeiro tipo de seus operandos. Se os tipos são diferentes, então o resultado é falso. Caso contrário, os valores dos operandos são comparados. Números e cadeias são comparadas na forma usual. Objetos (tabelas, userdata, thread e funções) são comparadas por referência: dois objetos são considerados iguais somente se eles são o mesmo objeto. Toda vez que você criar um novo objeto (uma tabela, userdata, thread ou função), este novo objeto é diferente de qualquer objeto que existia anteriormente.

Você pode alterar a maneira como Lua compara tabelas e userdata usando o metamétodo "eq" (ver § 2.8).

As regras de conversão do § 2.2.1 não se aplicam a comparações de igualdade. Assim, "0" == 0 é avaliada como falsa, e t [0] e t ["0"] denotam posições diferentes em uma tabela.

O operador ~ = é exatamente a negação da igualdade (==).

Os operadores de ordem trabalham da seguinte forma. Se ambos os argumentos são números, então eles são comparados como tal. Caso contrário, se ambos os argumentos são strings, então seus valores são comparados de acordo com a localidade. Caso contrário, Lua tenta chamar o "lt" ou o "le" metamétodo (ver § 2.8). A comparação a> b é traduzida para b <a e a> = b é traduzida para b <= a. 2.5.3 - Operadores lógicos

Os operadores lógicos em Lua são e, ou e não. Como as estruturas de controle (ver § 2.4.4), todos os operadores lógicos consideram false e nil como falso e qualquer outra coisa como verdadeira.

O operador de negação not sempre retorna falso ou verdadeiro. O operador de conjunção e retorna seu primeiro argumento se este valor for falso ou nulo, caso contrário, e retorna seu segundo argumento. O operador de disjunção or retorna seu primeiro argumento se este valor for diferente de zero e falso, caso contrário, ou retorna seu segundo argumento. Ambos ee ou usar curto corte avaliação, isto é, o segundo operando é avaliada apenas se for necessário. Aqui estão alguns exemplos:

 

10 ou 20 -> 10

10 ou error () -> 10

nil ou "a" -> "a"

nil e 10 -> nil

falsa e erro () -> false

falsas e nulo -> falso

false ou nil - nil>

10 e 20 -> 20

 

(Neste manual, -> indica o resultado da expressão anterior.) 2.5.4 - Concatenação

O operador de concatenação de strings em Lua é denotado por dois pontos ('..'). Se ambos os operandos são cadeias ou números, então eles são convertidos em seqüências de acordo com as regras mencionadas no § 2.2.1. Caso contrário, o "concat" metamétodo é chamado (ver § 2.8). 2.5.5 - O operador de tamanho

O operador de tamanho é denotado pelo operador unário #. O comprimento de uma string é o número de bytes (ou seja, o significado usual de comprimento de cadeia quando cada caractere ocupa um byte).

O comprimento de uma tabela t é definido como qualquer índice inteiro n tal que t [n] não é nulo e t [n +1] é nil, além disso, se t [1] é nil, n pode ser zero. Para uma matriz regular, com não-nil valores de 1 a um dado n, o seu comprimento é exactamente que n, o índice do seu último valor. Se a matriz tem "furos" (isto é, valores nil entre outros não-nil valores), em seguida, # t pode ser qualquer um dos índices que precede diretamente um valor nulo (isto é, pode examinar qualquer valor nil como o fim da matriz). 2.5.6 - Precedência

Precedência de operadores em Lua segue a tabela abaixo, do menor ao maior prioridade:

 

ou

e

<> <=> = ~ ===

..

+ -

*% /

não # - (unário)

^

Como de costume, você pode usar parênteses para alterar as precedências de uma expressão. A concatenação ('..') e exponenciação ('^') são associativos à direita. Todos os demais operadores binários são associativos à esquerda. 2.5.7 - Construtores Tabela

Construtores de tabelas são expressões que criam tabelas. Cada vez que um construtor é avaliado, uma nova tabela é criada. Um construtor pode ser usado para criar uma tabela vazia ou para criar uma tabela e inicializar alguns dos seus campos. A sintaxe geral para os construtores é

tableconstructor :: = `{'[fieldlist]`}' fieldlist :: = campo {field fieldsep} [fieldsep] campo :: = `['exp`]' `= 'exp | Nome` =' exp | exp fieldsep :: = `, '|`;'

Cada campo do formulário [exp1] = exp2 adiciona à nova tabela uma entrada cuja chave é exp1 e exp2 valor. Um campo da forma nome = exp é equivalente a ["name"] = exp. Finalmente, os campos da forma exp são equivalentes a = exp, onde i são números inteiros consecutivos, começando com 1. Campos em outros formatos não afetam esta contagem. Por exemplo,

 

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

é equivalente a

 

fazer

local t = {}

t [f (1)] = g

t [1] = "x" - 1 ª exp

t [2] = "y" - exp 2

t.x = 1 - t ["x"] = 1

t [3] = f (x) - exp 3

t [30] = 23

t [4] = 45 - exp 4

um t =

final

Se o último campo na lista tem a forma exp ea expressão é uma chamada de função ou uma expressão vararg, então todos os valores retornados por esta expressão entram na lista consecutivamente (ver § 2.5.8). Para evitar isso, coloque a chamada de função ou a expressão vararg entre parênteses (ver § 2.5).

A lista de campos pode ter um separador no fim, como uma conveniência para código gerado. 2.5.8 - As chamadas de função

Uma chamada de função em Lua tem a seguinte sintaxe:

FunctionCall :: = args expprefixo

Em uma chamada de função, em primeiro lugar expprefixo e args são avaliados. Se o valor de expprefixo tem o tipo de função, então esta função é chamada com os argumentos fornecidos. Caso contrário, o expprefixo "call" metamétodo é chamado, tendo como primeiro parâmetro o valor de expprefixo, seguido pelos argumentos originais da chamada (ver § 2.8).

A forma

FunctionCall :: = expprefixo `: 'Nome args

pode ser usada para chamar "métodos". Uma chamada v: nome (args) é um açúcar sintático para v.name (v, args), exceto que v é avaliado apenas uma vez.

Argumentos têm a seguinte sintaxe:

args :: = `('[explist]`)' args :: tableconstructor = args :: String =

Todas as expressões argumento são avaliadas antes da chamada. Uma chamada da forma f {campos} é um açúcar sintático para f ({campos}), isto é, a lista de argumentos é uma tabela nova. Uma chamada da forma f'string '(ou f "cadeia" ou f [[cadeia]]) é um açúcar sintático para f (' string '), ou seja, a lista de argumentos é uma única seqüência literal.

Como exceção à sintaxe de formato livre de Lua, você não pode colocar uma quebra de linha antes do '(' em uma chamada de função. Esta restrição evita algumas ambigüidades na linguagem. Se você escrever

 

um f =

(G). X (a)

Lua poderia ver isto como uma única declaração, a. = F (g). X (a) Então, se você quiser duas afirmações, você deve adicionar um ponto e vírgula entre eles. Se você realmente deseja chamar f, você deve remover a quebra de linha antes de (g).

Uma chamada da forma return é chamado de uma chamada de cauda. Lua implementa chamadas finais próprias (ou recursões finais próprias): em uma chamada de cauda, ​​a função chamada reutiliza a entrada na pilha da função de chamada. Portanto, não há limite para o número de chamadas de cauda aninhadas que um programa pode executar. No entanto, a chamada cauda apaga qualquer informação de depuração sobre a função de chamada. Observe que uma chamada final somente acontece com uma sintaxe particular, onde o retorno tem uma única chamada de função como argumento; esta sintaxe faz com que o retorno de chamada de função exatamente o retorno da função chamada. Então, nenhum dos exemplos que se seguem são chamadas finais:

 

return (f (x)) - resultados ajustado para 1

return 2 * f (x)

retorno x, f (x) - resultados adicionais

f (x); retorno - resultados descartados

retornar x ou f (x) - resultados ajustado para 1

2.5.9 - Definições de função

A sintaxe para definição de função é

função :: = função funcbody funcbody :: = `('[parlist]`)' bloco end

O seguinte açúcar sintático simplifica definições de funções:

comando :: = função funcname funcbody comando :: = funcbody nome local da função funcname :: = Nome {`'Nome [`.}:' Nome]

A declaração

 

função f () corpo end

traduz-se

 

f extremidade do corpo = function ()

A declaração

 

função t.a.b.c.f () corpo end

traduz-se

 

t.a.b.c.f extremidade do corpo = function ()

A declaração

 

f função local () corpo end

traduz-se

 

f local; f extremidade do corpo = function ()

não

 

extremidade do corpo local f = function ()

(Isso só faz diferença quando o corpo da função contém referências a f.)

Uma definição de função é uma expressão executável, cujo valor tem a função de tipo. Quando Lua pré-compila um pedaço, todos os corpos das funções são pré-compilados também. Então, sempre que Lua executa a definição da função, a função é instanciada (ou fechada). Esta instância da função (ou encerramento) é o valor final da expressão. Diferentes instâncias da mesma função pode se referir a diferentes variáveis ​​locais externas e podem ter diferentes tabelas de ambiente.

Parâmetros atuar como variáveis ​​locais que são inicializadas com os valores de argumento:

parlist :: = namelist [`, '` ...'] | `... '

Quando uma função é chamado, a lista de argumentos é ajustado para o comprimento da lista de parâmetros, a menos que a função é uma função variádica ou vararg, que é indicado por três pontos ('...') no final do seu parâmetro lista. Uma função vararg não ajusta sua lista de argumentos, em vez disso, ela coleta todos os argumentos extras e os fornece para a função através de uma expressão vararg, que também é representada como três pontos. O valor desta expressão é uma lista de todos os argumentos extras, semelhantes a uma função com vários resultados. Se uma expressão vararg é utilizado dentro de outra expressão ou no meio de uma lista de expressões, então a sua lista de retorno é ajustada para um elemento. Se a expressão é usada como o último elemento de uma lista de expressões, então nenhum ajuste é feito (a menos que última expressão é colocado entre parênteses).

Como exemplo, considere as seguintes definições:

 

final função f (a, b)

função g (a, b, ...) final

função r () return 1,2,3 final

Então, temos o seguinte mapeamento de argumentos para parâmetros e para a expressão vararg:

 

CHAMADA DE PARÂMETROS

 

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, ... -> (Nada)

g (3, 4) a = 3, b = 4, ... -> (Nada)

g (3, 4, 5, 8) a = 3, b = 4, ... -> 5 8

g (5, r ()) a = 5, b = 1, ... -> 2 3

Os resultados são retornados usando a instrução return (ver § 2.4.4). Se o controle chega ao fim de uma função sem encontrar um comando return, então a função retorna sem resultados.

A sintaxe do cólon é usado para a definição de métodos, isto é, as funções que têm um parâmetro implícito auto extra. Assim, a instrução

 

t.a.b.c função: f extremidade do corpo (params)

é um açúcar sintático para

 

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

2.6 - Regras de visibilidade

Lua é uma linguagem com escopo léxico. O escopo das variáveis ​​começa na primeira declaração após a sua declaração e dura até o final do bloco mais interno que inclui a declaração. Considere o seguinte exemplo:

 

x = 10 - variável global

fazer - novo bloco

local x = x - nova 'x', com valor 10

print (x) -> 10

x = x +1

fazer - outro bloco

local x = x +1 - outro 'x'

print (x) -> 12

final

print (x) -> 11

final

print (x) -> 10 (o global)

Observe que, em uma declaração como local x = x, o novo x sendo declarado não está no escopo ainda e portanto o segundo x refere-se a variável fora.

Por causa das regras de escopo léxico, variáveis ​​locais podem ser livremente acessadas por funções definidas dentro do seu escopo. Uma variável local utilizado por uma função interna é chamada de upvalue, ou variável local externa, dentro da função interna.

Observe que cada execução de um comando local define novas variáveis ​​locais. Considere o seguinte exemplo:

 

a = {}

local x = 20

para i = 1,10 fazer

y = 0 locais

a = function () y = y +1; return x + y final

final

 

O laço cria dez fechos (isto é, dez instâncias da função anônima). Cada um destes fechos usa uma variável y diferente, embora todos eles compartilham o mesmo x. 2.7 - Tratamento de erros

Porque Lua é uma linguagem de extensão integrado, todas as ações de Lua começam a partir do código C no programa host chamando uma função da biblioteca de Lua (ver lua_pcall). Sempre que ocorre um erro durante a compilação ou execução, o controle retorna para C, que pode tomar medidas apropriadas (tais como imprimir uma mensagem de erro).

Código Lua pode explicitamente gerar um erro chamando a função de erro. Se você precisa capturar erros em Lua, você pode usar a função pcall. 2.8 - Metatabelas

Todo valor em Lua pode ter uma metatabela. Esta metatabela é uma tabela Lua comum que define o comportamento do valor original, sob certas operações especiais. Você pode alterar vários aspectos do comportamento de operações sobre um valor especificando campos específicos em sua metatabela. Por exemplo, quando um valor não-numérico é o operando de uma adição, Lua verifica a existência de uma função no campo "__add" em sua metatabela. Se encontrar um, Lua chama essa função para realizar a adição.

Chamamos as chaves em uma metatabela de eventos e os valores de metamétodos. No exemplo anterior, o evento é "add" eo metamétodo é a função que realiza a adição.

Você pode consultar a metatabela de qualquer valor através da função getmetatable.

Você pode mudar a metatabela de tabelas através da função setmetatable. Você não pode mudar a metatabela de outros tipos de Lua (exceto usando a biblioteca de depuração), você deve usar a API C para isso.

Tabelas e userdata completo tem metatabelas individuais (embora várias tabelas e userdata podem partilhar as suas metatabelas). Valores de todos os outros tipos compartilham uma metatabela por tipo, ou seja, há uma metatabela para todos os números, um para todas as cordas, etc

A metatabela controla como um objeto se comporta em operações aritméticas, comparações de ordem, concatenação, operação comprimento e indexação. Uma metatabela também pode definir uma função para ser chamada quando um objeto userdata é coletado. Para cada um destes Lua operações associa uma chave específica chamada um evento. Quando Lua realiza uma destas operações sobre um valor, ele verifica se este valor possui uma metatabela com o evento correspondente. Se assim for, o valor associado com essa chave (o metamétodo) controla como Lua irá realizar a operação.

Metatabelas controlam as operações listadas a seguir. Cada operação é identificado pelo seu nome correspondente. A chave para cada operação é uma string com o seu nome precedido por dois sublinhados, '__', por exemplo, a chave para a operação "add" é a cadeia "__add". A semântica destas operações é melhor explicada por uma função Lua que descreve como o intérprete executa a operação.

O código mostrado aqui em Lua é apenas ilustrativa; o comportamento real está codificado no interpretador e é muito mais eficiente do que esta simulação. Todas as funções usadas nestas descrições (rawget, tonumber, etc) são descritos em § 5,1. Em particular, para recuperar o metamétodo de um dado objeto, usamos a expressão

 

metatable (obj) [evento]

Isto deve ser lido como

 

rawget (getmetatable (obj) {} ou, caso)

Ou seja, o acesso a um metamétodo não invoca metamétodos outros, eo acesso a objetos que não metatabelas não falha (ele simplesmente resulta em nil).

 

"Adicionar": a operação +.

 

O getbinhandler função abaixo define como Lua escolhe um tratador para uma operação binária. Primeiro, Lua tenta o primeiro operando. Se seu tipo não define um tratador para a operação, então Lua tenta o segundo operando.

 

getbinhandler função (op1, op2, o evento)

voltar metatable (op1) [evento] ou metatabela (op2) [evento]

final

 

Ao utilizar esta função, o comportamento do op1 + op2 é

 

função add_event (op1, op2)

local, O1, O2 = tonumber (op1), tonumber (op2)

se o1 e o2 então - ambos os operandos são numéricos?

voltar o1 + o2 - '+' aqui é o primitivo 'add'

o resto -, pelo menos, um dos operandos não é numérico

local h = getbinhandler (op1, op2, "__add")

Se H então

- Chama o tratador com ambos os operandos

return (h (op1, op2))

outra pessoa - sem tratador disponível: comportamento padrão

error (· · ·)

final

final

final

 

"Sub": a operação -. Comportamento similar ao da operação "add".

"Mul": a operação *. Comportamento similar ao da operação "add".

"Div": a operação /. Comportamento similar ao da operação "add".

"Mod": a operação%. Comportamento similar ao da operação "add", com a operação o1 - floor (o1/o2) * o2 como operação primitiva.

"Pow": a ^ (exponenciação) operação. Comportamento similar ao da operação "add", com a função pow (a partir da biblioteca de matemática C) como operação primitiva.

"Unm": o unário - operação.

 

função unm_event (op)

local, o = tonumber (op)

se o então - operando é numérico?

return-o - '-' aqui é a 'unm' primitivo

outra coisa - o operando não é numérico.

- Tentar obter um manipulador do operando

local h = metatable (op). __unm

Se H então

- Chama o tratador com o operando

return (h (op))

outra pessoa - sem tratador disponível: comportamento padrão

error (· · ·)

final

final

final

 

"Concat": o .. (Concatenação).

 

função concat_event (op1, op2)

if (type (op1) == "string" ou tipo (op1) == "number") e

(Tipo (op2) == "string" ou tipo (op2) == "number"), então

voltar op1 .. op2 - concatenação primitivo

outro

local h = getbinhandler (op1, op2, "__concat")

Se H então

return (h (op1, op2))

outro

error (· · ·)

final

final

final

 

"Len": a operação #.

 

função len_event (op)

se o tipo (op) == "string", em seguida,

voltar strlen (op) - comprimento da cadeia primitiva

elseif tipo (op) == "tabela" e depois

retornar # op - comprimento da tabela primitiva

outro

local h = metatable (op). __len

Se H então

- Chama o tratador com o operando

return (h (op))

outra pessoa - sem tratador disponível: comportamento padrão

error (· · ·)

final

final

final

 

Ver § 2.5.5 para uma descrição do comprimento de uma mesa.

"Eq": a operação. == A função getcomphandler define como Lua escolhe um metamétodo para operadores de comparação. Um metamétodo só é selecionado quando ambos os objetos que estão sendo comparados têm o mesmo tipo eo mesmo metamétodo para a operação selecionada.

 

getcomphandler função (op1, op2, o evento)

se o tipo (op1) ~ = tipo (op2), em seguida, retornar nil end

locais mm1 = metatable (op1) [evento]

locais mm2 = metatable (op2) [evento]

se mm1 == mm2, em seguida, retornar mm1 else return nil end

final

 

O "eq" acontecimento é definido como segue:

 

função eq_event (op1, op2)

se o tipo (op1) ~ = tipo (op2) then - tipos diferentes?

return false - objetos diferentes

final

se op1 == op2 então - primitivo igual?

return true - objetos são iguais

final

- Tente metamétodo

local h = getcomphandler (op1, op2, "__eq")

Se H então

return (h (op1, op2))

outro

return false

final

final

 

um ~ = b é equivalente a não (a == b).

"Lt": a operação <.

 

função lt_event (op1, op2)

se o tipo (op1) == "number" e digite (op2) == "number", em seguida,

voltar op1 <op2 - comparação numérica

elseif tipo (op1) == "string" e tipo (op2) == "string", em seguida,

voltar op1 <op2 - comparação lexicográfica

outro

local h = getcomphandler (op1, op2, "__lt")

Se H então

return (h (op1, op2))

outro

error (· · ·)

final

final

final

 

a> b é equivalente a b <a.

"Le": o <= operação.

 

função le_event (op1, op2)

se o tipo (op1) == "number" e digite (op2) == "number", em seguida,

voltar op1 <= op2 - comparação numérica

elseif tipo (op1) == "string" e tipo (op2) == "string", em seguida,

voltar op1 <= op2 - comparação lexicográfica

outro

local h = getcomphandler (op1, op2, "__le")

Se H então

return (h (op1, op2))

outro

h = getcomphandler (op1, op2, "__lt")

Se H então

retornar não h (op2, op1)

outro

error (· · ·)

final

final

final

final

 

a> = b é equivalente a b <= a. Note-se que, na ausência de um metamétodo "le", Lua tenta o "lt", assumindo que a <= b é equivalente a não (b <a).

"Index": A tabela de acesso indexação [chave].

 

função gettable_event (table, key)

h locais

se o tipo (tabela) == "tabela" e depois

v = rawget locais (tabela, chave)

se v ~ = nil then return end v

h = metatable (tabela). __index

se h == nil then return end nil

outro

h = metatable (tabela). __index

se h == nil then

error (· · ·)

final

final

se o tipo (h) == "function", em seguida,

return (h (de mesa, chave)) - chama o tratador

else return h [key] - ou repita a operação nela

final

final

 

"Newindex": A tabela de atribuição de indexação [chave] = valor.

 

função settable_event (tabela, chave, valor)

h locais

se o tipo (tabela) == "tabela" e depois

v = rawget locais (tabela, chave)

se v ~ = nil then rawset (tabela, chave, valor); final retorno

h = metatable (tabela). __newindex

se h == nil then rawset (tabela, chave, valor); final retorno

outro

h = metatable (tabela). __newindex

se h == nil then

error (· · ·)

final

final

se o tipo (h) == "function", em seguida,

h (table, key, value) - chama o tratador

outra h [key] = value - operação ou repetição nele

final

final

 

"Call": chamada quando Lua chama um valor.

 

function_event função (func, ...)

se o tipo (func) == "function", em seguida,

voltar func (...) - chamada primitiva

outro

local h = metatable (func). __call

Se H então

retornar h (func, ...)

outro

error (· · ·)

final

final

final

2.9 - Ambientes

Além metatables, objetos de tipos de função thread, e userdata possuem outra tabela associada com elas, chamada de seu ambiente. Como metatables, ambientes são tabelas normais e vários objetos podem compartilhar o mesmo ambiente.

Tópicos são criados compartilhando o ambiente do segmento de criação. Funções userdata e C são criados dividindo o ambiente da função C criando. Funções não-aninhados Lua (criado por loadfile, loadstring ou de carga) são criados compartilhando o ambiente do segmento de criação. Funções aninhadas Lua são criados partilha o ambiente da função Lua criando.

Ambientes associados com userdata não possuem significado para Lua. É só uma característica de conveniência para programadores para associar uma tabela para um userdata.

Ambientes associados com tópicos são chamados ambientes globais. Eles são usados ​​como o ambiente padrão para tópicos e funções não aninhadas Lua criadas pela thread e pode ser acessado diretamente pelo código C (ver § 3.3).

O ambiente associado a uma função C pode ser acessado diretamente pelo código C (ver § 3.3). É usado como o ambiente padrão para outras funções C e userdata criados pela função.

Ambientes associados com funções Lua são usados ​​para resolver todos os acessos a variáveis ​​globais dentro da função (ver § 2.3). Eles são utilizados como o ambiente padrão para funções aninhadas Lua criadas pela função.

Você pode mudar o ambiente de uma função Lua ou do segmento em execução chamando setfenv. Você pode obter o ambiente de uma função Lua ou do segmento em execução chamando getfenv. Para manipular o ambiente de outros objetos (userdata, funções C, outros), você deve usar a API C. 2.10 - Coleta de Lixo

Lua realiza gerenciamento automático de memória. Isso significa que você tem que se preocupar nem sobre a alocação de memória para novos objetos nem com a liberação quando os objetos não são mais necessários. Lua gerencia a memória automaticamente executando um coletor de lixo ao longo do tempo para recolher todos os objetos mortos (isto é, objetos que não são mais acessíveis a partir de Lua). Toda a memória usada por Lua está sujeita a gestão automática: tabelas, userdata, funções, fios, cordas, etc

Lua implementa um coletor de marca-e-varrer incremental. Ele usa dois números para controlar os seus ciclos de coleta de lixo: a pausa do coletor de lixo e do multiplicador de passo do coletor de lixo. Ambas utilizam pontos percentuais, como unidades (de modo que um valor de 100 significa um valor interno de 1).

A pausa do coletor de lixo controla quanto tempo o coletor espera antes de iniciar um novo ciclo. Valores maiores fazem o coletor ser menos agressivo. Valores menores que 100 significa que o coletor não irá esperar para começar um novo ciclo. Um valor de 200 significa que o colector de espera para a memória total no uso de dobrar antes de iniciar um novo ciclo.

O multiplicador de passo controla a velocidade relativa do colector em relação à atribuição de memória. Valores maiores fazem o colector mais agressivo, mas também aumentar o tamanho de cada passo incremental. Valores inferiores a 100 fazem o colector muito lento e pode resultar no colector nunca terminando um ciclo. O padrão, 200, significa que o coletor é executado em "duas vezes" a velocidade de alocação de memória.

Você pode alterar esses números, chamando às funções lua_gc em C ou collectgarbage na Lua. Com estas funções você também pode controlar o coletor diretamente (por exemplo, pare e reinicie-o). 2.10.1 - coleta de lixo metamétodos

Usando a API C, você pode definir coletor de lixo metamétodos para userdata (ver § 2.8). Estes metamétodos também são chamados de finalizadores. Finalizadores permitem coordenar coleta de lixo de Lua com a gestão de recursos externos (tais como fechar arquivos, conexões de rede ou banco de dados, ou a liberação de sua própria memória).

Objetos userdata com um campo __ gc em suas metatabelas não são recolhidos imediatamente pelo coletor de lixo. Em vez disso, Lua os coloca em uma lista. Após a coleta, a Lua faz o equivalente da seguinte função para cada userdata nessa lista:

 

função gc_event (udata)

local h = metatable (udata). __gc

Se H então

h (udata)

final

final

No final de cada ciclo de coleta de lixo, os finalizadores para userdata são chamados na ordem inversa da sua criação, entre aqueles coletados naquele ciclo. Ou seja, o primeiro finalizador a ser chamado é aquele associado com a última userdata criado no programa. O userdata si só é liberado no ciclo de coleta de lixo próxima. 2.10.2 - Tabelas fracos

Uma tabela fraca é uma tabela cujos elementos são referências fracas. Uma referência fraca é ignorada pelo coletor de lixo. Em outras palavras, se as únicas referências para um objeto são referências fracas, então o coletor de lixo irá coletar este objeto.

Uma tabela fraca pode ter chaves fracas, valores fracos, ou ambos. Uma tabela com chaves fracas permite a coleta de suas chaves, mas impede a cobrança de seus valores. Uma tabela com chaves fracas e valores fracos permite a coleta de ambas as chaves e valores. Em qualquer caso, se a chave ou o valor é recolhido, o par de todo é removido a partir da tabela. A fragilidade de uma tabela é controlada pelo campo __ mode de sua metatabela. Se o campo __ mode é uma string contendo 'k' do personagem, as chaves da tabela são fracos. Se __ mode contém 'v', os valores da tabela são fracos.

Depois de usar uma tabela como uma metatabela, você não deve alterar o valor de seu campo __ mode. Caso contrário, o comportamento fraco das tabelas controladas por esta metatabela é indefinido. 2.11 - co-rotinas

Lua suporte co-rotinas, também chamados de multithreading colaborativo. Uma co-rotina em Lua representa um fluxo de execução independente. Ao contrário de threads em sistemas multithread, no entanto, uma co-rotina somente suspende a sua execução chamando explicitamente uma função de produção.

Você cria uma co-rotina com uma chamada para coroutine.create. O seu único argumento é uma função que é a principal função da co-rotina. A função create somente cria uma nova co-rotina e retorna um identificador para ela (um objeto do tipo thread), mas não iniciar a execução co-rotina.

Quando você chamar coroutine.resume, passando como primeiro argumento uma thread retornado por coroutine.create, a co-rotina inicia a sua execução, na primeira linha da sua função principal. Argumentos extras passados ​​para coroutine.resume são passados ​​para a função de co-rotina principal. Após a co-rotina começa a ser executado, ele executa até terminar ou ceder.

Uma função pode terminar a sua execução de duas maneiras: normalmente, quando sua função principal retorna (explicitamente ou implicitamente, após a última instrução), e de forma anormal, se houver um erro desprotegido. No primeiro caso, coroutine.resume retorna true mais quaisquer valores retornados pela função de co-rotina principal. Em caso de erros, coroutine.resume retorna false mais uma mensagem de erro.

A produção co-rotina chamando coroutine.yield. Quando uma produção co-rotina, o coroutine.resume correspondente retorna imediatamente, mesmo se o rendimento acontece chamadas de função dentro aninhadas (que não é, na função principal, mas em uma função chamada direta ou indiretamente pela função principal). No caso de um rendimento, coroutine.resume também retorna verdadeiro, além de quaisquer valores passados ​​para coroutine.yield. A próxima vez que você retomar a co-rotina mesmo, ela continua sua execução a partir do ponto onde ela cedeu, com a chamada para coroutine.yield retornando quaisquer argumentos extras passados ​​para coroutine.resume.

Como coroutine.create, a função coroutine.wrap também cria uma co-rotina, mas em vez de voltar a co-rotina em si, ele retorna uma função que, quando chamada, retoma a co-rotina. Quaisquer argumentos passados ​​para essa função vão como argumentos extras para coroutine.resume. coroutine.wrap retorna todos os valores retornados por coroutine.resume, exceto o primeiro (o código de erro boolean). Ao contrário coroutine.resume, coroutine.wrap não detectar erros, pois qualquer erro é propagado para o chamador.

Como exemplo, considere o seguinte código:

 

function foo (a)

print ("foo", a)

voltar coroutine.yield (2 * a)

final

 

CO = coroutine.create função ((a, b)

print ("co-corpo", a, b)

local, r = foo (a +1)

print ("co-corpo", r)

locais r, s = coroutine.yield (a + b, um-b)

print ("co-corpo", r, s)

retornar b, "fim"

fim)

 

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"))

Quando você executa-lo, ele produz o seguinte resultado:

 

co-corpo 1 10

foo 2

 

4 verdadeiro principal

co-r corpo

principal verdadeira 11 -9

co-corpo x, y

principal fim 10 true

falsa principal não pode retomar a co-rotina mortos

3 - A Interface de Programa Aplicativo

Esta secção descreve a API C para Lua, isto é, o conjunto de funções C disponíveis para o programa de acolhimento para comunicar com Lua. Todas as funções da API e tipos relacionados e constantes são declaradas no arquivo de cabeçalho lua.h.

Mesmo quando usamos o termo "função", qualquer operação na API pode ser fornecida como uma macro. Todas as macros tais usar cada um de seus argumentos exatamente uma vez (exceto para o primeiro argumento, que é sempre um estado Lua), e assim não geram quaisquer efeitos secundários oculto.

Como na maioria das bibliotecas C, as funções da API Lua não verificam os seus argumentos para a validade ou consistência. No entanto, você pode alterar este comportamento compilando Lua com uma definição apropriada para o luai_apicheck macro, em luaconf.h arquivo. 3.1 - A Pilha

Lua usa uma pilha virtual para passar valores de e para C. Cada elemento nesta pilha representa um valor Lua (nil, número, string, etc.)

Sempre que Lua chama C, a função chamada recebe uma nova pilha, que é independente de pilhas anteriores e de pilhas de funções C que ainda estão ativos. Esta pilha contém inicialmente quaisquer argumentos para a função C e é onde a função C empilha os seus resultados a serem retornados ao chamador (ver lua_CFunction).

Por conveniência, a maioria das operações de consulta na API não seguem uma disciplina estrita de pilha. Em vez disso, eles podem referir a qualquer elemento da pilha usando um índice: Um índice positivo representa uma posição absoluta na pilha (a partir de 1); um índice negativo representa um deslocamento relativo ao topo da pilha. Mais especificamente, se a pilha tem n elementos, então o índice 1 representa o primeiro elemento (isto é, o elemento que foi empurrada para a primeira pilha) e índice n representa o último elemento; índice -1 representa também o último elemento (isto é , o elemento no topo) e índice de-n representa o primeiro elemento. Dizemos que um índice é válido se ele está entre 1 eo topo da pilha (isto é, se 1 ≤ abs (índice) ≤ topo). 3.2 - Tamanho Stack

Quando você interage com a API de Lua, você é responsável por assegurar a coerência. Em particular, você é responsável por controlar estouro de pilha. Você pode usar a função lua_checkstack para aumentar o tamanho da pilha.

Sempre que Lua chama C, ele garante que, pelo menos nas posições de pilha LUA_MINSTACK estão disponíveis. LUA_MINSTACK é definida como 20, de modo que normalmente você não precisa se preocupar com espaço de pilha a menos que seu código tem laços empurrando elementos na pilha.

A maioria das funções de consulta aceita como índices qualquer valor dentro do espaço disponível na pilha, ou seja, índices até o tamanho máximo da pilha tiver definido através lua_checkstack. Tais índices são chamados índices aceitáveis. Mais formalmente, definimos um índice aceitável como segue:

 

(Índice <0 && abs (índice) <= topo) | |

(Índice> 0 && índice <=)

Note-se que 0 nunca é um índice aceitável. 3.3 - Pseudo-índices

Salvo disposição em contrário, qualquer função que aceita índices válidos pode também ser chamado de pseudo-índices, que representam alguns valores Lua que são acessíveis para o código C, mas que não estão na pilha. Pseudo-índices são usados ​​para acessar o ambiente de discussão, o ambiente de função, o registro, e os upvalues ​​de uma função C (ver § 3.4).

O ambiente de execução (onde as variáveis ​​globais existem) está sempre no pseudo-índice LUA_GLOBALSINDEX. O ambiente da função C rodando está sempre no pseudo-índice LUA_ENVIRONINDEX.

Para acessar e alterar o valor de variáveis ​​globais, você pode usar operações de tabelas usuais sobre uma tabela de ambiente. Por exemplo, para aceder ao valor de uma variável global, fazer

 

lua_getfield (L, LUA_GLOBALSINDEX, varname);

3.4 - C Closures

Quando uma função C é criada, é possível associar alguns valores com ela, criando então um fecho C; estes valores são chamados upvalues ​​e são acessíveis para a função sempre que for chamado (ver lua_pushcclosure).

Sempre que uma função C é chamada, seus upvalues ​​estão localizados em pseudo-índices específicos. Estes pseudo-índices são produzidos pela lua_upvalueindex macro. O primeiro valor associado a uma função está em posição lua_upvalueindex (1), e assim por diante. Qualquer acesso a lua_upvalueindex (n), onde n é maior do que o número de upvalues ​​da função de corrente (mas não maior do que 256), produz um índice de (mas inválido) aceitável. 3.5 - Registro

Lua fornece um registo, uma tabela de pré-definida que pode ser utilizado por qualquer código C para armazenar qualquer valor Lua que necessita para armazenar. Esta tabela está sempre localizada no pseudo-índice LUA_REGISTRYINDEX. Qualquer biblioteca C pode armazenar dados para esta tabela, mas deve tomar cuidado para escolher chaves diferentes daquelas usadas por outras bibliotecas, para evitar colisões. Normalmente, você deve usar como uma seqüência de chave que contém o nome da biblioteca ou um userdata leve com o endereço de um objeto C em seu código.

As chaves inteiras no registro são usados ​​pelo mecanismo de referência, implementado pela biblioteca auxiliar e, portanto, não deve ser utilizado para outros fins. 3.6 - Tratamento de erros em C

Internamente, Lua usa o C facilidade longjmp para lidar com erros. (Você também pode optar por usar exceções se você usar o C + +; ver luaconf.h arquivo.) Quando Lua se depara com qualquer erro (como erros de alocação de memória, erros do tipo, erros de sintaxe e erros de execução) ele gera um erro, isto é, ele faz um salto em comprimento. Um ambiente protegido usa setjmp para definir um ponto de recuperação; qualquer erro salta para o mais recente ponto de recuperação ativa.

A maioria das funções da API pode lançar um erro, por exemplo, devido a um erro de alocação de memória. A documentação de cada função indica se ele pode jogar erros.

Dentro de uma função C que você pode jogar um erro chamando lua_error. 3.7 - Funções e tipos de

Aqui, listamos todas as funções e tipos da API C em ordem alfabética. Cada função tem um indicador como este: [-o, + p, x]

O primeiro campo, o, é quantos elementos a função desempilha da pilha. O segundo campo, p, é quantos elementos a função empilha na pilha. (Qualquer função sempre empilha os seus resultados após estourar seus argumentos.) Um campo na forma x | y significa que a função pode empurrar (ou pop) elementos x ou y, dependendo da situação, um ponto de interrogação '?' significa que não podemos saber quantos elementos a função desempilha / empilha olhando somente os seus argumentos (por exemplo, podem depender do que está na pilha). O terceiro campo, x, diz-se a função pode disparar erros: '-' significa que a função nunca dispara qualquer erro; 'm' significa que a função pode disparar um erro somente devido à memória insuficiente; 'e' significa que a função pode disparar outros tipos de erros; "v", a função pode disparar um erro de propósito. lua_Alloc

typedef void * (lua_Alloc *) (void * ud,

void * ptr,

osize size_t,

nsize size_t);

O tipo da função de alocação de memória usada por Lua estados. A função de alocação deve fornecer uma funcionalidade semelhante ao realloc, mas não exatamente o mesmo. Seus argumentos são ud, um ponteiro opaco passado para lua_newstate; ptr, um ponteiro para o bloco sendo alocado / realocado / liberado; osize, o tamanho original do bloco; nsize, o novo tamanho do bloco. ptr é NULL se e somente se osize é zero. Quando nsize é zero, a alocação deve retornar NULL; se osize não é zero, ele deve liberar o bloco apontado por ptr. Quando nsize não é zero, o alocador retorna NULL se e somente se ele não pode preencher a solicitação. Quando nsize não é zero e osize é zero, o alocador deve se comportar como malloc. Quando nsize e osize não são zero, o alocador se comporta como realloc. Lua assume que nunca falha quando o alocador osize> = nsize.

Aqui está uma simples aplicação para a função de alocação. É utilizado na biblioteca auxiliar por luaL_newstate.

 

static void * l_alloc (void * ud, void * ptr osize, size_t,

nsize size_t) {

(Void) ud; (void) osize / * não usado * /

if (nSize == 0) {

livre (ptr);

retornar NULL;

}

outro

voltar realloc (ptr, nsize);

}

Este código assume que free (NULL) não tem efeito e que realloc (NULL, size) é equivalente ao malloc (tamanho). ANSI C garante esses dois comportamentos. lua_atpanic

[-0, +0, -]

lua_CFunction lua_atpanic (lua_State * L, lua_CFunction panicf);

Define uma função de pânico nova e retorna o antigo.

Se um erro ocorre fora de qualquer ambiente protegido, Lua chama uma função pânico e então chama exit (EXIT_FAILURE), saindo assim do aplicativo host. Sua função pânico pode evitar esta saída por nunca voltar (por exemplo, fazendo um salto em comprimento).

A função de pânico pode aceder a mensagem de erro no topo da pilha. lua_call

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

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

Chama uma função.

Para chamar uma função você deve usar o seguinte protocolo: primeiro, a função a ser chamada é empurrado para a pilha, então, os argumentos da função são empilhados em ordem direta, isto é, o primeiro argumento é empilhado primeiro. Finalmente você chama lua_call; nargs é o número de argumentos que você empurrou para a pilha. Todos os argumentos eo valor da função são exibidos da pilha quando a função é chamada. Os resultados da função são empurrados para a pilha quando a função retorna. O número de resultados é ajustado para nresults, a menos que nresults é LUA_MULTRET. Neste caso, todos os resultados da função são empilhados. Lua cuida para que os valores retornados caibam dentro do espaço de pilha. Os resultados da função são empurrados para a pilha, de modo directo (o primeiro resultado é empurrado em primeiro lugar), de modo que após a chamada o último resultado está no topo da pilha.

Qualquer erro dentro da função chamada é propagado para cima (com um longjmp).

O exemplo a seguir mostra como o programa hospedeiro pode fazer o equivalente a este código Lua:

 

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

Aqui está em C:

 

lua_getfield (L, LUA_GLOBALSINDEX, "f"); / * função a ser chamada * /

lua_pushstring (L, "como"); / * primeiro argumento * /

lua_getfield (L, LUA_GLOBALSINDEX, "t"); tabela / * para ser indexado * /

lua_getfield (L, -1, "x"); / * empilha o resultado de tx (2 º arg) * /

lua_remove (L, -2); / * remove 't' da pilha * /

lua_pushinteger (L, 14); / * argumento 3 * /

lua_call (L, 3, 1) / * 'f' chamada com 3 argumentos e 1 resultado * /

lua_setfield (L, LUA_GLOBALSINDEX, "a"); / * definir global 'a' * /

Observe que o código acima é "equilibrada": ao seu final, a pilha está de volta à sua configuração original. Isso é considerado boa prática de programação. lua_CFunction

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

Tipo C para funções.

A fim de comunicar apropriadamente com Lua, uma função C deve usar o seguinte protocolo, que define a forma como os parâmetros e resultados são passados: uma função C recebe seus argumentos de Lua na sua pilha em ordem direta (o primeiro argumento é empilhado primeiro). Então, quando a função começa, lua_gettop (L) retorna o número de argumentos recebidos pela função. O primeiro argumento (se houver) está no índice 1 e seu último argumento é o índice lua_gettop (L). Para retornar valores para Lua, uma função C apenas os empilha na pilha, em ordem direta (o primeiro resultado é empilhado primeiro), e retorna o número de resultados. Qualquer outro valor na pilha abaixo dos resultados será devidamente descartado pela Lua. Como uma função Lua, uma função C chamada por Lua também pode retornar muitos resultados.

Como um exemplo, a seguinte função recebe um número variável de argumentos numéricos e retorna a sua média e soma:

 

static int foo (lua_State * L) {

int n = lua_gettop (L), número / * argumentos * /

lua_Number sum = 0;

int i;

for (i = 1; i <= n; i + +) {

if (! lua_isnumber (L, i)) {

lua_pushstring (L ", argumento incorreto");

lua_error (L);

}

soma + = lua_tonumber (L, i);

}

lua_pushnumber (L, soma / n) / * primeiro resultado * /

lua_pushnumber (L, soma); / * segundo resultado * /

retornará 2, número / * dos resultados * /

}

lua_checkstack

[-0, 0, m]

int lua_checkstack (lua_State * L, int extra);

Assegura que há pelo menos extras posições da pilha livres na pilha. Ele retorna false se não pode crescer a pilha para esse tamanho. Esta função nunca comprime a pilha, se a pilha já é maior do que o novo tamanho, ele é deixado inalterado. lua_close

[-0, +0, -]

vazio lua_close (lua_State * L);

Destrói todos os objetos no estado Lua fornecido (chamando os correspondentes de coleta de lixo metamétodos, se houver) e libera toda a memória dinâmica usada por esse estado. Em várias plataformas, você pode não precisar de chamar essa função, porque todos os recursos são naturalmente liberados quando o programa hospedeiro termina. Por outro lado, de longa duração programas, como um daemon ou um servidor de web, podem ter de libertar estados logo que eles não são necessários, para evitar a crescer muito grande. lua_concat

[-N, 1, e]

vazio lua_concat (lua_State * L, int n);

Concatena os valores de n, na parte superior da pilha, aparece eles, e deixa o resultado no topo. Se n é 1, o resultado é o único valor na pilha (isto é, a função não faz nada); se n é 0, o resultado é a cadeia vazia. A concatenação é realizada de acordo com a semântica usual de Lua (ver § 2.5.4). lua_cpcall

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

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

Chama a função C func em modo protegido. func começa com apenas um elemento na sua pilha, um objeto userdata leve contendo ud. No caso de erros, lua_cpcall retorna os códigos de erro mesmas lua_pcall, mais o objecto de erro no topo da pilha, caso contrário, retorna a zero, e não altera a pilha. Todos os valores retornados por func são descartados. lua_createtable

[-0, 1, m]

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

Cria uma nova tabela vazia e empurra-o para a pilha. A nova tabela tem espaço pré-alocado para elementos de matriz Narr e nrec não-array elementos. Esta pré-alocação é útil quando você sabe exatamente quantos elementos a tabela terá. Caso contrário, você pode usar a função lua_newtable. lua_dump

[-0, 0, m]

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

Despeja uma função como um trecho de código binário. Recebe uma função Lua no topo da pilha e produz um pedaço binário que, se carregado novamente, resulta em uma função equivalente à uma despejado. Como se produz partes do pedaço, lua_dump chama a função writer (ver lua_Writer) com os dados fornecidos a escrevê-los.

O valor devolvido é o código de erro retornado pela última chamada para o escritor; 0 significa sem erros.

Esta função não aparecer a função Lua da pilha. lua_equal

[-0, +0, E]

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

Retorna 1 se os dois valores nos índices aceitáveis ​​index1 e index2 são iguais, seguindo a semântica do operador == Lua (ou seja, pode chamar metamétodos). Caso contrário retorna 0. Também retorna 0 se qualquer um dos índices não é válido. lua_error

[-1, 0, v]

int lua_error (lua_State * L);

Gera um erro Lua. A mensagem de erro (que pode realmente ser um valor Lua de qualquer tipo) deve estar no topo da pilha. Esta função faz um salto em comprimento, e, portanto, nunca retorna. (Ver luaL_error). às funções lua_gc

[-0, +0, E]

int às funções lua_gc (lua_State * L, int o que, dados int);

Controla o coletor de lixo.

Esta função executa várias tarefas, de acordo com o valor do parâmetro que:

 

LUA_GCSTOP: pára o coletor de lixo.

LUA_GCRESTART: reinicia o coletor de lixo.

LUA_GCCOLLECT: realiza um ciclo de coleta de lixo cheio.

LUA_GCCOUNT: retorna a quantidade de memória (em Kbytes) em uso por Lua.

LUA_GCCOUNTB: retorna o resto da divisão da quantidade de bytes de memória em uso por Lua por 1024.

LUA_GCSTEP: realiza um passo incremental de coleta de lixo. A etapa "tamanho" é controlado por dados (valores maiores significam mais passos) de uma forma não-especificado. Se você quiser controlar o tamanho do passo que você deve experimentalmente ajustar o valor dos dados. A função retorna 1 se o passo finalizou um ciclo de coleta de lixo.

LUA_GCSETPAUSE: define dados como o novo valor para a pausa do coletor (ver § 2.10). A função retorna o valor anterior da pausa.

LUA_GCSETSTEPMUL: conjuntos de dados como o novo valor para o multiplicador de passo do coletor (ver § 2.10). A função retorna o valor anterior do multiplicador de passo.

lua_getallocf

[-0, +0, -]

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

Retorna a função de alocação de memória de um determinado estado. Se ud não é NULL, Lua armazena em * ud o ponteiro opaco passado para lua_newstate. lua_getfenv

[-0, 1, -]

vazio lua_getfenv (lua_State * L, int index);

Coloca na pilha a tabela de ambiente do valor no índice fornecido. lua_getfield

[-0, 1, e]

vazio lua_getfield (lua_State * L, índice int, const char * k);

Coloca na pilha o valor t [k], onde t é o valor no índice válido fornecido. Como em Lua, esta função pode disparar um metamétodo para o evento "index" (ver § 2.8). lua_getglobal

[-0, 1, e]

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

Coloca na pilha o valor do nome global. É definida como um macro:

 

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

lua_getmetatable

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

int lua_getmetatable (lua_State * L, int index);

Coloca na pilha a metatabela do valor no índice aceitável fornecido. Se o índice não é válido, ou se o valor não tem uma metatabela, a função retorna 0 e não coloca nada na pilha. lua_gettable

[-1, +1, E]

lua_gettable void (lua_State * L, int index);

Coloca na pilha o valor t [k], onde t é o valor no índice válido fornecido e k é o valor no topo da pilha.

Esta função desempilha a chave da pilha (colocando o resultado em seu lugar). Como em Lua, esta função pode disparar um metamétodo para o evento "index" (ver § 2.8). lua_gettop

[-0, +0, -]

int lua_gettop (lua_State * L);

Retorna o índice do elemento superior da pilha. Porque os índices começam em 1, este resultado é igual ao número de elementos na pilha (e assim 0 significa uma pilha vazia). lua_insert

[-1, +1, -]

vazio lua_insert (lua_State * L, int index);

Move o elemento do topo para o índice válido fornecido, deslocando os elementos acima deste índice para abrir espaço. Não pode ser chamada com um pseudo-índice, porque um pseudo-índice não é uma posição real da pilha. lua_Integer

typedef ptrdiff_t lua_Integer;

O tipo usado pela API Lua para representar valores inteiros.

Por padrão, ele é um ptrdiff_t, que normalmente é o maior tipo assinado integrante da máquina manipula "confortavelmente". lua_isboolean

[-0, +0, -]

int lua_isboolean (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido possui tipo booleano e 0 caso contrário. lua_iscfunction

[-0, +0, -]

int lua_iscfunction (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é uma função C, e 0 caso contrário. lua_isfunction

[-0, +0, -]

int lua_isfunction (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é uma função (C ou Lua), e 0 caso contrário. lua_islightuserdata

[-0, +0, -]

int lua_islightuserdata (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é um objeto userdata leve e 0 caso contrário. lua_isnil

[-0, +0, -]

int lua_isnil (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido for nil e 0 caso contrário. lua_isnone

[-0, +0, -]

int lua_isnone (lua_State * L, int index);

Retorna 1 se o índice aceitável fornecido não é válido (isto é, refere-se a um elemento fora da pilha corrente), e 0 caso contrário. lua_isnoneornil

[-0, +0, -]

int lua_isnoneornil (lua_State * L, int index);

Retorna 1 se o índice aceitável fornecido não é válido (isto é, refere-se a um elemento fora da pilha corrente) ou se o valor neste índice é nulo, e 0 caso contrário. lua_isnumber

[-0, +0, -]

int lua_isnumber (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido for um número ou uma string convertida para um número, e 0 caso contrário. lua_isstring

[-0, +0, -]

int lua_isstring (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é uma string ou um número (que é sempre conversível para uma string), e 0 caso contrário. lua_istable

[-0, +0, -]

int lua_istable (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido for uma tabela, e 0 caso contrário. lua_isthread

[-0, +0, -]

int lua_isthread (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é um thread e 0 caso contrário. lua_isuserdata

[-0, +0, -]

int lua_isuserdata (lua_State * L, int index);

Retorna 1 se o valor no índice aceitável fornecido é um objeto userdata (completo ou leve), e 0 caso contrário. lua_lessthan

[-0, +0, E]

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

Retorna 1 se o valor no índice aceitável index1 é menor do que o valor no índice aceitável index2, seguindo a semântica do operador <Lua (ou seja, pode chamar metamétodos). Caso contrário retorna 0. Também retorna 0 se qualquer um dos índices não é válido. lua_load

[-0, 1, -]

int lua_load (lua_State * L,

lua_Reader leitor,

* dados vazio,

const char * chunkname);

Carrega um pedaço de Lua. Se não há erros, lua_load empurra o pedaço compilado como uma função Lua no topo da pilha. Caso contrário, ele empurra uma mensagem de erro. Os valores de retorno de lua_load são:

 

0: sem erros;

LUA_ERRSYNTAX: erro de sintaxe durante o pré-compilação;

LUA_ERRMEM: erro de alocação de memória.

Esta função carrega apenas um pedaço, mas não executá-lo.

lua_load detecta automaticamente se o trecho é de texto ou binário, e carrega-lo em conformidade (ver Luac programa).

A função lua_load usa uma função reader fornecida pelo usuário para ler o trecho (ver lua_Reader). O argumento data é um valor opaco passado para a função de leitor.

O argumento chunkname dá um nome ao trecho, que é usado para mensagens de erro e em informações de depuração (ver § 3.8). lua_newstate

[-0, +0, -]

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

Cria um estado novo e independente. Retorna NULL se não puder criar o estado (devido à falta de memória). O argumento f é a função de alocação; Lua faz toda a alocação de memória para este estado através desta função. O segundo argumento, ud, é um ponteiro opaco que Lua simplesmente passa para a alocação a cada chamada. lua_newtable

[-0, 1, m]

vazio lua_newtable (lua_State * L);

Cria uma nova tabela vazia e empurra-o para a pilha. É equivalente a lua_createtable (L, 0, 0). lua_newthread

[-0, 1, m]

lua_State * lua_newthread (lua_State * L);

Cria um novo segmento, coloca-o na pilha e retorna um ponteiro para um lua_State que representa este novo segmento. O novo estado retornado por esta função compartilha com o estado original de todos os objetos globais (como tabelas), mas tem uma pilha de execução independente.

Não existe nenhuma função explícita para terminar ou para destruir uma lista de discussão. Threads estão sujeitas à coleta de lixo, como qualquer outro objeto Lua. lua_newuserdata

[-0, 1, m]

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

Esta função aloca um novo bloco de memória com o tamanho especificado, coloca na pilha um novo objeto userdata completo com o endereço do bloco, e retorna este endereço.

Userdata representam valores C em Lua.. Um userdata completo representa um bloco de memória. É um objeto (como uma tabela): você deve criá-lo, ele pode ter sua própria metatabela, e você pode detectar quando ele está sendo coletado. Um userdata completo é apenas igual a si próprio (sob a igualdade em bruto).

Quando Lua coleta um userdata completo com um metamétodo gc, Lua chama o metamétodo e marca o userdata como finalizado. Quando este userdata é coletado novamente então Lua libera sua memória correspondente. lua_next

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

int lua_next (lua_State * L, int index);

Aparece uma chave da pilha, e um par chave-valor da tabela no índice determinado (o par "next", depois de uma chave). Se não há mais elementos na tabela, então lua_next retorna 0 (e não empilha nada).

Um percorrimento típico parece com isso:

 

/ * Tabela está na pilha de 't' index * /

lua_pushnil (L); / key * primeiro * /

while (lua_next (L, t) = 0) {

/ * Usa "chave" (no índice -2) e "valor" (no índice -1) * /

printf ("% s -% s \ n",

lua_typename (L, lua_type (L, -2)),

lua_typename (L, lua_type (L, -1)));

/ * Remove 'valor'; mantém 'chave' para a próxima iteração * /

lua_pop (L, 1);

}

Ao atravessar uma tabela, não chame lua_tolstring diretamente em uma chave, a menos que você sabe que a chave é realmente uma cadeia. Lembre-se que lua_tolstring altera o valor no índice fornecido, o que confunde a próxima chamada para lua_next. lua_Number

lua_Number typedef double;

O tipo de números em Lua. Por padrão, ele é o dobro, mas que pode ser mudado em luaconf.h.

Através do arquivo de configuração que você pode mudar Lua para operar com outro tipo de números (por exemplo, float ou long). lua_objlen

[-0, +0, -]

size_t lua_objlen (lua_State * L, int index);

Retorna o "tamanho" do valor no índice aceitável fornecido: para cadeias de caracteres, este é o comprimento da corda; para tabelas, este é o resultado do operador de comprimento ('#'); para userdata, este é o tamanho do bloco de memória alocado para o userdata; para outros valores, é 0. lua_pcall

[- (Nargs + 1), + (nresults | 1), -]

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

Chama uma função em modo protegido.

Ambos os nargs e nresults possuem o mesmo significado que no lua_call. Se não houver erros durante a chamada, lua_pcall se comporta exatamente como lua_call. No entanto, se não há qualquer erro, lua_pcall pega, empurra um único valor para a pilha (a mensagem de erro), e retorna um código de erro. Como lua_call, lua_pcall sempre remove a função e seus argumentos da pilha.

Se errfunc é 0, então a mensagem de erro retornada na pilha é exatamente a mensagem de erro original. Caso contrário, errfunc é o índice de pilha de uma função de manipulador de erro. (Na implementação atual, este índice não pode ser um pseudo-índice.) Em caso de erros de execução, esta função será chamada com a mensagem de erro e seu valor de retorno será a mensagem retornada na pilha por lua_pcall.

Normalmente, a função de manipulador de erro é usada para adicionar mais informação de depuração para a mensagem de erro, como um stack. Tal informação não pode ser obtida após o retorno de lua_pcall, pois até então a pilha tem desenrolado.

A função lua_pcall retorna 0 em caso de sucesso ou um dos seguintes códigos de erro (definido no lua.h):

 

LUA_ERRRUN: um erro de execução.

LUA_ERRMEM: erro de alocação de memória. Para tais erros, Lua não chama a função de manipulador de erro.

LUA_ERRERR: erro ao executar a função de manipulador de erro.

lua_pop

[-N, 0, -]

vazio lua_pop (lua_State * L, int n);

Pops n elementos da pilha. lua_pushboolean

[-0, 1, -]

vazio lua_pushboolean (lua_State * L, int b);

Coloca um valor booleano com valor b na pilha. lua_pushcclosure

[-N, 1, m]

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

Coloca um novo fecho C na pilha.

Quando uma função C é criada, é possível associar alguns valores com ela, criando assim um fecho C (ver § 3.4); estes valores são então acessíveis para a função sempre que é chamado. Para associar valores com uma função C, primeiro esses valores devem ser colocados na pilha (quando há vários valores, o primeiro valor é empilhado primeiro). Então lua_pushcclosure é chamado para criar e colocar a função C na pilha, com o argumento n informando quantos valores devem ser associados com a função. lua_pushcclosure também desempilha estes valores da pilha.

O valor máximo para n é 255. lua_pushcfunction

[-0, 1, m]

vazio lua_pushcfunction (lua_State * L, lua_CFunction f);

Empilha uma função C na pilha. Esta função recebe um ponteiro para uma função C e coloca na pilha um valor Lua do tipo function que, quando chamado, invoca a função C correspondente.

Qualquer função para ser registrada em Lua deve seguir o protocolo correto para receber seus parâmetros e retornar seus resultados (ver lua_CFunction).

lua_pushcfunction é definido como um macro:

 

# Define lua_pushcfunction (L, f) lua_pushcclosure (L, f, 0)

lua_pushfstring

[-0, 1, m]

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

Coloca na pilha uma string formatada e retorna um ponteiro para esta cadeia. É semelhante à função C sprintf, mas tem algumas diferenças importantes:

 

Você não tem que alocar espaço para o resultado: o resultado é uma string e Lua cuida da alocação de memória (e desalocação, através da coleta de lixo).

Os especificadores de conversão são bastante restritos. Não há flags, tamanhos ou precisões. Os especificadores de conversão só pode ser '%%' (insere um '%' na cadeia), '% s' (insere uma string terminada em zero, sem restrições de tamanho), '% f' (insere um lua_Number), ' % p '(insere um ponteiro como um numeral hexadecimal),'% d '(insere um int), e'% c '(insere um int como um caractere).

lua_pushinteger

[-0, 1, -]

vazio lua_pushinteger (lua_State * L, lua_Integer n);

Coloca um número com valor n na pilha. lua_pushlightuserdata

[-0, 1, -]

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

Coloca um userdata leve na pilha.

Userdata representam valores C em Lua.. Um userdata leve representa um ponteiro. É um valor (como um número): você não criá-lo, não tem metatabela individual, e não é coletado (como nunca foi criado). Um userdata leve é ​​igual a userdata "qualquer" luz com o endereço C mesmo. lua_pushliteral

[-0, 1, m]

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

Esta macro é equivalente a lua_pushlstring, mas pode ser usado somente quando s é uma string literal. Nestes casos, ele automaticamente fornece o comprimento da corda. lua_pushlstring

[-0, 1, m]

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

Coloca a string apontada por s com tamanho len na pilha. Lua faz (ou reutiliza) uma cópia interna da cadeia fornecida, de modo a memória de s pode ser liberada ou reutilizada imediatamente após o retorno da função. A cadeia pode conter zeros. lua_pushnil

[-0, 1, -]

vazio lua_pushnil (lua_State * L);

Coloca um valor nil na pilha. lua_pushnumber

[-0, 1, -]

vazio lua_pushnumber (lua_State * L, lua_Number n);

Coloca um número com valor n na pilha. lua_pushstring

[-0, 1, m]

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

Coloca a cadeia terminada por zero apontada por s na pilha. Lua faz (ou reutiliza) uma cópia interna da cadeia fornecida, de modo a memória de s pode ser liberada ou reutilizada imediatamente após o retorno da função. A cadeia não pode conter zeros dentro; presume-se para terminar em primeiro zero. lua_pushthread

[-0, 1, -]

int lua_pushthread (lua_State * L);

Empurra o segmento representado por L na pilha. Retorna 1 se este segmento é o segmento principal do seu estado. lua_pushvalue

[-0, 1, -]

vazio lua_pushvalue (lua_State * L, int index);

Coloca uma cópia do elemento no índice válido fornecido na pilha. lua_pushvfstring

[-0, 1, m]

const char * lua_pushvfstring (lua_State * L,

const char * fmt,

va_list argp);

Equivalente a lua_pushfstring, exceto que ele recebe uma va_list em vez de um número variável de argumentos. lua_rawequal

[-0, +0, -]

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

Retorna 1 se os dois valores nos índices aceitáveis ​​index1 e index2 são iguais primitivamente (isto é, sem chamar metamétodos). Caso contrário retorna 0. Também retorna 0 se qualquer um dos índices não for válido. lua_rawget

[-1, +1, -]

vazio lua_rawget (lua_State * L, int index);

Similar a lua_gettable, mas faz um acesso bruto (isto é, sem metamétodos). lua_rawgeti

[-0, 1, -]

vazio lua_rawgeti (lua_State * L, índice int, int n);

Coloca na pilha o valor t [n], onde t é o valor no índice válido fornecido. O acesso é crua, ou seja, ela não invoca metamétodos. lua_rawset

[-2, 0, m]

vazio lua_rawset (lua_State * L, int index);

Similar a lua_settable, mas faz uma atribuição primitiva (isto é, sem metamétodos). lua_rawseti

[-1, 0, m]

vazio lua_rawseti (lua_State * L, índice int, int n);

Faz o equivalente de t [n] = v, onde t é o valor no índice válido fornecido e v é o valor no topo da pilha.

Esta função desempilha o valor da pilha. A atribuição é primitiva, isto é, ela não invoca metamétodos. lua_Reader

typedef char * (* lua_Reader) (lua_State * L,

* dados vazio,

* size_t tamanho);

A função de leitura utilizado por lua_load. Toda vez que precisa de outro pedaço do pedaço, lua_load chama o leitor, passando ao longo de seu parâmetro de dados. O leitor deve retornar um ponteiro para um bloco de memória com um novo pedaço do tamanho do bloco e conjunto ao tamanho do bloco. O bloco deve existir até que a função de leitor é chamado novamente. Para sinalizar o fim do trecho, o leitor deve retornar NULL ou definir o tamanho para zero. A função de leitura pode retornar pedaços de qualquer tamanho maior do que zero. lua_register

[-0, +0, E]

vazio lua_register (lua_State * L,

const char * name,

lua_CFunction f);

Define a função C f como o novo valor de nome global. É definida como um macro:

 

# Define lua_register (L, N, F) \

(Lua_pushcfunction (L, f), lua_setglobal (L, N))

lua_remove

[-1, 0, -]

vazio lua_remove (lua_State * L, int index);

Remove o elemento no índice válido fornecido, deslocando para baixo os elementos acima deste índice para preencher a lacuna. Não pode ser chamada com um pseudo-índice, porque um pseudo-índice não é uma posição real da pilha. lua_replace

[-1, 0, -]

vazio lua_replace (lua_State * L, int index);

Move o elemento do topo para a posição fornecida (e desempilha-lo), sem deslocar qualquer elemento (substituindo assim o valor na posição determinada). lua_resume

[-?, +, -?]

int lua_resume (lua_State * L, int narg);

Começa e recomeça uma co-rotina em um determinado segmento.

Para iniciar uma co-rotina, primeiro você cria um novo segmento (ver lua_newthread), então você empurrar para sua pilha a função principal mais quaisquer argumentos, então você chamar lua_resume, com narg sendo o número de argumentos. Essa chamada retorna quando a co-rotina suspende ou termina a sua execução. Quando ele retorna, a pilha contém todos os valores passados ​​para lua_yield ou todos os valores retornados pelo corpo da função. lua_resume retorna lua_yield se os rendimentos co-rotina, 0 se a co-rotina termina sua execução sem erros, ou um código de erro em caso de erros (ver lua_pcall). Em caso de erros, a pilha não é desfeita, assim você pode usar a API de depuração sobre ela. A mensagem de erro está no topo da pilha. Para reiniciar uma co-rotina, você coloca na pilha dela somente os valores a serem passados ​​como resultados de yield e então chamar lua_resume. lua_setallocf

[-0, +0, -]

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

Muda a função de alocação de um dado estado para f com objeto userdata ud. lua_setfenv

[-1, 0, -]

int lua_setfenv (lua_State * L, int index);

Aparece uma tabela da pilha e define-o como o novo ambiente para o valor no índice fornecido. Se o valor no índice fornecido não é nem uma função nem um fio nem um userdata, lua_setfenv retorna 0. Caso contrário, retorna 1. lua_setfield

[-1, 0, e]

vazio lua_setfield (lua_State * L, índice int, const char * k);

Faz o equivalente t [k] = v, onde t é o valor no índice válido fornecido e v é o valor no topo da pilha.

Esta função desempilha o valor da pilha. Como em Lua, esta função pode disparar um metamétodo para o evento "newindex" (ver § 2.8). lua_setglobal

[-1, 0, e]

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

Retira um valor da pilha e define-o como o novo valor de nome global. É definida como um macro:

 

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

lua_setmetatable

[-1, 0, -]

int lua_setmetatable (lua_State * L, int index);

Aparece uma tabela da pilha e estabelece esta como a metatabela novo para o valor no índice aceitável fornecido. lua_settable

[-2, 0, e]

anular lua_settable (lua_State * L, int index);

Faz o equivalente t [k] = v, onde t é o valor no índice válido fornecido, v é o valor no topo da pilha, e k é o valor um pouco abaixo do topo.

Esta função desempilha a chave e o valor da pilha. Como em Lua, esta função pode disparar um metamétodo para o evento "newindex" (ver § 2.8). lua_settop

[-?, +, -?]

vazio lua_settop (lua_State * L, int index);

Aceita qualquer índice aceitável, ou 0, e define o topo da pilha a este índice. Se o novo topo é maior do que o antigo, em seguida, os novos elementos são preenchidos com nil. Se o índice for 0, então todos os elementos da pilha são removidos. lua_State

typedef struct lua_State lua_State;

Estrutura opaca que guarda todo o estado de um intérprete de Lua. A biblioteca de Lua é totalmente reentrante: não tem variáveis ​​globais. Todas as informações sobre o estado é mantido nesta estrutura.

Um ponteiro para este estado deve ser passado como o primeiro argumento para todas as funções na biblioteca, exceto para lua_newstate, que cria um estado Lua a partir do zero. lua_status

[-0, +0, -]

int lua_status (lua_State * L);

Retorna o status da linha L.

O status pode ser 0 para uma linha normal, um código de erro se o segmento terminou sua execução com um erro, ou lua_yield se o segmento está suspenso. lua_toboolean

[-0, +0, -]

int lua_toboolean (lua_State * L, int index);

Converte o valor Lua no índice aceitável fornecido para um valor booleano C (0 ou 1). Como todos os testes na Lua, lua_toboolean retorna 1 para qualquer valor Lua diferente de false e nil, caso contrário, retorna 0. Ele também retorna 0 quando chamada com um índice não-válido. (Se você quiser aceitar somente valores booleanos, use lua_isboolean para testar o tipo do valor.) lua_tocfunction

[-0, +0, -]

lua_CFunction lua_tocfunction (lua_State * L, int index);

Converte um valor no índice aceitável fornecido para uma função C. Esse valor deve ser uma função C, caso contrário, retorna NULL. lua_tointeger

[-0, +0, -]

lua_Integer lua_tointeger (lua_State * L, int index);

Converte o valor Lua no índice aceitável fornecido para o tipo assinado lua_Integer integral. O valor Lua deve ser um número ou uma string convertida para um número (ver § 2.2.1), caso contrário, lua_tointeger retorna 0.

Se o número não é um número inteiro, será truncado de alguma forma não especificada. lua_tolstring

[-0, 0, m]

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

Converte o valor Lua no índice aceitável fornecido para uma cadeia de C. Se len não é NULL, ele também define len * com o comprimento da corda. O valor Lua deve ser uma string ou um número, caso contrário, a função retorna NULL. Se o valor for um número, então lua_tolstring também altera o valor real na pilha para uma string. (Esta mudança confunde lua_next quando lua_tolstring é aplicada a chaves durante um percorrimento de tabela.)

lua_tolstring retorna um ponteiro totalmente alinhado para uma cadeia no interior do estado Lua. Esta cadeia sempre tem um zero ('\ 0') após a sua último caracter (como em C), mas pode conter outros zeros no seu corpo. Porque Lua tem coleta de lixo, não há garantia de que o ponteiro retornado por lua_tolstring será válida após o valor correspondente é retirado da pilha. lua_tonumber

[-0, +0, -]

lua_Number lua_tonumber (lua_State * L, int index);

Converte o valor Lua no índice aceitável fornecido para o lua_Number tipo C (ver lua_Number). O valor Lua deve ser um número ou uma string convertida para um número (ver § 2.2.1), caso contrário, lua_tonumber retorna 0. lua_topointer

[-0, +0, -]

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

Converte o valor no índice aceitável fornecido para um ponteiro C genérico (void *). O valor pode ser um objeto userdata, uma tabela, um fio, ou uma função, caso contrário, lua_topointer retorna NULL. Diferentes objetos dará ponteiros diferentes. Não há maneira de converter o ponteiro de volta ao seu valor original.

Normalmente esta função é usada apenas para informações de depuração. lua_tostring

[-0, 0, m]

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

Equivalente a lua_tolstring com len igual a NULL. lua_tothread

[-0, +0, -]

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

Converte o valor no índice aceitável fornecido para uma linha Lua (representado como * lua_State). Este valor deve ser um fio, caso contrário, a função retorna NULL. lua_touserdata

[-0, +0, -]

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

Se o valor no índice aceitável fornecido é um objeto userdata completo, retorna o endereço do bloco. Se o valor for um objeto userdata leve, retorna seu ponteiro. Caso contrário, retorna NULL. lua_type

[-0, +0, -]

int lua_type (lua_State * L, int index);

Retorna o tipo do valor no índice aceitável fornecido ou LUA_TNONE para um índice não-válidos (ou seja, um índice para uma posição de pilha "vazio"). Os tipos retornados por lua_type são codificados pelas seguintes constantes definidas em lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD e LUA_TLIGHTUSERDATA. lua_typename

[-0, +0, -]

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

Retorna o nome do tipo codificado pelo valor tp, que deve ser um dos valores retornados por lua_type. lua_Writer

typedef int (* lua_Writer) (lua_State * L,

const void * p,

sz size_t,

void * ud);

O tipo de função de escrita usada por lua_dump. Toda vez que ela produz outro pedaço de trecho, lua_dump chama o escritor, passando junto o buffer a ser escrito (p), seu tamanho (sz) eo parâmetro os dados fornecidos para lua_dump.

O escritor retorna um código de erro: 0 significa nenhum erro; qualquer outro valor significa um erro e pára lua_dump de chamar o escritor novamente. lua_xmove

[-?, +, -?]

vazio lua_xmove (lua_State * from, lua_State * a, int n);

Valores de troca entre os diferentes segmentos do mesmo estado global.

Esta função desempilha n valores da pilha from e os empilha na pilha para. lua_yield

[-?, +, -?]

int lua_yield (lua_State * L, nresults int);

Produz uma co-rotina.

Esta função só deve ser chamado como a expressão de retorno de uma função C, como segue:

 

voltar lua_yield (L, nresults);

Quando uma função C chama lua_yield desta forma, a co-rotina sendo executada suspende a sua execução, ea chamada para lua_resume que iniciou esta co-rotina retorna. O parâmetro results é o número de valores da pilha que são transmitidos como resultados a lua_resume. 3.8 - A interface de depuração

Lua não tem embutido recursos de depuração. Em vez disso, ele oferece uma interface especial por meio de funções e ganchos. Esta interface permite a construção de diferentes tipos de depuradores, profilers, e outras ferramentas que precisam de "informação privilegiada" do intérprete. lua_Debug

typedef struct {lua_Debug

int evento;

const char * nome; / * (n) * /

const char * namewhat / * (n) * /

const char * o / * (S) * /

const char * origem; / * (S) * /

int currentline / * (l) * /

nups int / * (u) número de upvalues ​​* /

int linedefined / * (S) * /

int lastlinedefined / * (S) * /

caractere short_src [LUA_IDSIZE]; / * (S) * /

/ * Parte privada * /

outros campos Lua_Debug};

A estrutura usada para guardar diferentes pedaços de informação sobre uma função ativa. lua_getstack preenche apenas a parte privada desta estrutura, para uso posterior. Para preencher os outros campos de lua_Debug com informações úteis, ligue para lua_getinfo.

Os campos de lua_Debug têm o seguinte significado:

 

fonte: Se a função foi definida em uma string, então source é essa cadeia. Se a função foi definida em um arquivo, então source inicia com um "@" seguido do nome do arquivo.

short_src: uma versão "imprimível" da fonte, para ser usado em mensagens de erro.

linedefined: o número de linha em que a definição da função começa.

lastlinedefined: o número de linha em que a definição da função termina.

o que: a seqüência "Lua" se a função é uma função Lua, "C" se for uma função C, "principal", se é a parte principal de um trecho e "tail" se fosse uma função que fez uma chamada de cauda. Neste último caso, Lua não tem nenhuma outra informação sobre a função.

currentline: a linha atual onde a função fornecida está executando. Quando não há informações de linha está disponível, currentline é definido como -1.

name: um nome razoável para a função dada. Como as funções em Lua são valores de primeira classe, eles não têm um nome fixo: algumas funções podem ser o valor de múltiplas variáveis ​​globais, enquanto outros podem ser armazenados somente em um campo da tabela. A função lua_getinfo verifica como a função foi chamada para encontrar um nome adequado. Se não for possível encontrar um nome, o nome é definido como NULL.

namewhat: explica o campo de nome. O valor da namewhat pode ser "global", "local", "método", "campo", "upvalue", ou "" (string vazia), de acordo com a forma como a função foi chamada. (Lua usa a cadeia vazia quando nenhuma outra opção parece aplicar-se.)

nups: o número de upvalues ​​da função.

lua_gethook

[-0, +0, -]

lua_Hook lua_gethook (lua_State * L);

Retorna a função de gancho atual. lua_gethookcount

[-0, +0, -]

int lua_gethookcount (lua_State * L);

Retorna a contagem de gancho atual. lua_gethookmask

[-0, +0, -]

int lua_gethookmask (lua_State * L);

Retorna a máscara de gancho atual. lua_getinfo

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

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

Retorna informações sobre uma função específica ou invocação da função.

Para obter informações sobre uma chamada de função, o parâmetro ar deve ser um registro de ativação válido que foi preenchido por uma chamada anterior para lua_getstack ou dado como argumento para um gancho (ver lua_Hook).

Para obter informações sobre uma função que você empurrá-lo na pilha e iniciar a cadeia what com '>' o personagem. (Nesse caso, lua_getinfo aparece a função no topo da pilha.) Por exemplo, para saber em qual linha uma função f foi definida, você pode escrever o seguinte código:

 

lua_Debug ar;

lua_getfield (L, LUA_GLOBALSINDEX, "f"); / * obter global 'f' * /

lua_getinfo (L ",> S", e ar);

printf ("% d \ n", ar.linedefined);

Cada personagem na seqüência que seleciona alguns campos da estrutura ar para serem preenchidos ou um valor a ser empilhado na pilha:

 

'N': preenche o nome do campo e namewhat;

'S': preenche os campos de origem, short_src, linedefined, lastlinedefined, e que;

'L': preenche o campo currentline;

'U': preenche o campo nups;

'F': coloca na pilha a função que está executando no nível fornecido;

'L': coloca na pilha uma tabela cujos índices são os números das linhas que são válidas na função. (A linha válida é uma linha com algum código associado, isto é, uma linha onde você pode colocar um break point. Não-válidos linhas incluem linhas vazias e comentários.)

Esta função retorna 0 em caso de erro (por exemplo, uma opção inválida em what). lua_getlocal

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

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

Obtém informações sobre uma variável local de um registro de ativação fornecido. O parâmetro ar deve ser um registro de ativação válido que foi preenchido por uma chamada anterior para lua_getstack ou dado como argumento para um gancho (ver lua_Hook). O índice n seleciona qual variável local inspecionar (1 é o primeiro parâmetro ou variável local ativa, e assim por diante, até a última variável local ativa). lua_getlocal coloca o valor da variável na pilha e retorna seu nome.

Os nomes de variáveis ​​que começam com '(' (abre parênteses) representam variáveis ​​internas (variáveis ​​de controle de laços, temporários e locais de função C).

Retorna NULL (e empurra nada) quando o índice é maior do que o número de variáveis ​​locais activos. lua_getstack

[-0, +0, -]

int lua_getstack (lua_State * L, nível int, lua_Debug * ar);

Obtenha informações sobre a pilha de execução intérprete.

Esta função preenche partes de uma estrutura lua_Debug com uma identificação do registro de ativação da função de execução de um determinado nível. Nível 0 é a função atual em funcionamento, enquanto o nível n +1 é a função que chamou n nível. Quando não há erros, lua_getstack retorna 1; quando chamada com um nível maior do que a profundidade da pilha, ele retorna 0. lua_getupvalue

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

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

Obtém informações sobre upvalue de um fecho. (Para funções Lua, upvalues ​​são as variáveis ​​locais externas que a função utiliza, e que são, por conseguinte incluídos no seu fechamento.) Lua_getupvalue obtém o índice n de um upvalue, coloca o valor da upvalue na pilha, e retorna o seu nome. funcindex pontos para o encerramento na pilha. (Upvalues ​​tem nenhuma ordem particular, como eles são ativos ao longo de toda a função. Então, eles são numerados em uma ordem arbitrária.)

Retorna NULL (e empurra nada) quando o índice é maior do que o número de upvalues. Para funções C, esta função usa a cadeia vazia "" como um nome para todos os upvalues. lua_Hook

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

Tipo para a depuração de funções de gancho.

Sempre que um gancho é chamado, o seu argumento de ar tem seu evento campo definido para o evento específico que disparou o gancho. Lua identifica estes eventos com as seguintes constantes: LUA_HOOKCALL, LUA_HOOKRET, LUA_HOOKTAILRET, LUA_HOOKLINE e LUA_HOOKCOUNT. Além disso, para eventos de linha, o campo currentline também está definido. Para obter o valor de qualquer outro campo no ar, o gancho deve chamar lua_getinfo. Para eventos de retorno, o evento pode ser LUA_HOOKRET, o valor normal, ou LUA_HOOKTAILRET. Neste último caso, Lua está simulando um retorno de uma função que fez uma chamada de cauda, ​​neste caso, é inútil chamá lua_getinfo.

Enquanto Lua está executando um gancho, ela desabilita outras chamadas a ganchos. Portanto, se um gancho chama de volta Lua para executar uma função ou um pedaço, a execução ocorre sem quaisquer chamadas a ganchos. lua_sethook

[-0, +0, -]

int lua_sethook (lua_State * L, lua_Hook f, máscara int, int conta);

Define a função de gancho de depuração.

F argumento é a função de gancho. máscara especifica em que os eventos do gancho será chamado: ele é formado por um bit a bit ou do LUA_MASKCALL constantes, LUA_MASKRET, LUA_MASKLINE, e LUA_MASKCOUNT. O argumento de contagem só é significativo quando a máscara inclui LUA_MASKCOUNT. Para cada caso, o gancho é chamado, como explicado abaixo:

 

O gancho de chamada: é chamado quando o interpretador chama uma função. O gancho é chamado logo após Lua entrar na nova função, antes da função receber seus argumentos.

O gancho de retorno: é chamado quando o interpretador retorna de uma função. O gancho é chamado um pouco antes Lua deixa a função. Você não tem acesso aos valores a serem devolvidos pela função.

O gancho de linha: é chamado quando o intérprete está prestes a iniciar a execução de uma nova linha de código, ou quando ele pula de volta no código (mesmo para a mesma linha). (Este evento só acontece quando Lua está executando uma função Lua).

O gancho de contagem: é chamado após o interpretador executar cada count instruções. (Este evento só acontece quando Lua está executando uma função Lua).

Um gancho é desabilitado por se zero a mask. lua_setlocal

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

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

Define o valor de uma variável local de um registro de ativação fornecido. Os parâmetros ar e n são como na lua_getlocal (ver lua_getlocal). lua_setlocal atribui o valor no topo da pilha para a variável e retorna o seu nome. Também aparece o valor da pilha.

Retorna NULL (e aparece nada) quando o índice é maior do que o número de variáveis ​​locais activos. lua_setupvalue

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

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

Define o valor de upvalue de um fecho. Ele atribui o valor no topo da pilha para a upvalue e retorna o seu nome. Também aparece o valor da pilha. Parâmetros funcindex e n são como no lua_getupvalue (ver lua_getupvalue).

Retorna NULL (e aparece nada) quando o índice é maior do que o número de upvalues. 4 - A Biblioteca Auxiliar

A biblioteca auxiliar fornece várias funções convenientes para a interface C com Lua. Enquanto a API básica fornece as funções primitivas para todas as interações entre C e Lua, a biblioteca auxiliar fornece funções de nível superior para algumas tarefas comuns.

Todas as funções da biblioteca auxiliar são definidos em lauxlib.h ficheiro de cabeçalho e possuem um prefixo luaL_.

Todas as funções da biblioteca auxiliar são construídas no topo da API de base, e assim eles fornecem nada que não pode ser feito com esta API.

Várias funções na biblioteca auxiliar são usadas para verificar argumentos de funções C. Seus nomes são sempre * luaL_check ou * luaL_opt. Todas essas funções lançar um erro se o cheque não está satisfeito. Porque a mensagem de erro é formatada para argumentos (por exemplo, "bad argument # 1"), você não deve usar essas funções para valores de pilha outras. 4.1 - Funções e tipos de

Aqui, listamos todas as funções e tipos da biblioteca auxiliar em ordem alfabética. luaL_addchar

[-0, 0, m]

vazio luaL_addchar (luaL_Buffer * B, char c);

Adiciona o caractere c ao buffer B (ver luaL_Buffer). luaL_addlstring

[-0, 0, m]

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

Adiciona a string apontada por s com tamanho l ao buffer B (ver luaL_Buffer). A cadeia pode conter zeros. luaL_addsize

[-0, 0, m]

vazio luaL_addsize (luaL_Buffer * B, n size_t);

Adiciona ao buffer B (ver luaL_Buffer) uma seqüência de comprimento n copiada anteriormente para a área de buffer (ver luaL_prepbuffer). luaL_addstring

[-0, 0, m]

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

Adiciona a cadeia terminada por zero apontada por s ao buffer B (ver luaL_Buffer). A cadeia não pode conter zeros. luaL_addvalue

[-1, 0, m]

vazio luaL_addvalue (luaL_Buffer * B);

Adiciona o valor no topo da pilha para o tampão B (ver luaL_Buffer). Aparece o valor.

Esta é a função apenas em buffers de cadeias que podem (e deve) ser chamado com um elemento extra na pilha, que é o valor a ser adicionado ao tampão. luaL_argcheck

[-0, +0, V]

vazio luaL_argcheck (lua_State * L,

cond int

int narg,

const char * extramsg);

Verifica se cond é verdadeira. Se não, gera um erro com a seguinte mensagem, onde func é recuperada a partir da pilha de chamadas:

bad argument # <narg> para <func> (<extramsg>)

luaL_argerror

[-0, +0, V]

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

Gera um erro com a seguinte mensagem, onde func é recuperada a partir da pilha de chamadas:

 

bloco :: = trecho

 

funcname :: = Nome {`'Nome [`.}:' Nome]

varlist :: = var {`, 'var}

namelist :: = Nome {`, nome '}

 

expprefixo :: = var | chamadadefuncao | `('exp') '

função :: = função funcbody

funcbody :: = `('[parlist]`)' bloco end

parlist :: = namelist [`, '` ...'] | `... '

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

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

campo :: = `['exp`]' `= 'exp | Nome` =' exp | exp

fieldsep :: = `, '|`;'

 

 

 

 

 

 

O que é Lua?

Do wikipedia:

 

Lua (/ lu ː. Ə / LOO-ə) é leve, linguagem de programação reflexiva, imperativa e funcional, concebida como uma linguagem de script com semântica extensível como um objetivo primário. O nome vem da palavra lua Português significa "lua".

Qual é a diferença entre uma linguagem estática (como C ou C + +) e uma linguagem dinâmica como Lua?

 

Linguagem de programação dinâmica é um termo usado amplamente em ciência da computação para descrever uma classe de linguagens de programação de alto nível que executam em tempo de execução muitos comportamentos comuns que outras línguas pode realizar durante a compilação, se em tudo. (Wikipedia)

Por exemplo, onde uma variável em C tem um tipo ligado a ele, que não pode mudar (tipagem estática), uma variável em Lua é apenas um nome em que qualquer tipo de valor pode ser armazenado. (De certa forma, todas as variáveis ​​em Lua se comportam como ponteiros.) Mais interessante ainda, qualquer seqüência de código Lua válido pode ser executado dentro de outro script, abrindo a possibilidade de gerar novas funções em tempo de execução. Estruturas de dados podem mudar de tamanho e disposição durante a execução, e as funções podem ser passados ​​como qualquer outro objeto, tudo de acordo com os caprichos de entrada do usuário. (Algumas destas características são possíveis em C / C + + com um monte de codificação inteligente, mas o mais inteligente que o código fica, mais ela se torna como a máquina virual de um langauge interpretado de qualquer maneira ...)O que é interessante sobre Lua?

Fast (uma das mais rápidas linguagens dinâmicas). "Vários benchmarks mostram Lua como a linguagem mais rápida no domínio de linguagens de script interpretadas." Por esta razão em particular, é talvez o mais amplamente usado para o script do jogo. Além disso, o projeto LuaJIT usa um compilador de rastreamento para converter caminhos de código quentes e loops em código de máquina i386 ou x86_64, com um desempenho muitas vezes a par com C / C + +.

Expressivo. Lua começou como uma linguagem de descrição de dados, e continua a beneficiar de uma matriz universal e flexível / estrutura de dados hash. A sintaxe é essencialmente processual, no entanto, ele suporta plenamente funções de programação funcionais, tais como funções de primeira classe, tampas e co-rotinas e upvalues ​​escopo léxico (concessão de capacidades semelhantes para o esquema). Ele também suporta vários modelos de herança através de uma cadeia de herança protótipo (semelhante ao Auto e JavaScript). O tempo de execução também é totalmente reentrante.

Fácil de aprender. Realmente, a maioria da gramática da linguagem / sintaxe de uso / típico pode ser aprendido em um dia.

Extensible. Esses recursos expressivos, além de um sistema de módulos da biblioteca dinâmica (binário ou código Lua) se torna mais fácil estender Lua para um determinado projeto ou tarefa.

Pequeno. Lua como uma biblioteca estática é apenas um K centenas, tornando-o ideal para incorporação dentro de um programa hospedeiro.

Simplificação da API C. A simplicidade de Lua de ligação para o código C é frequentemente citado como uma atracção principal da Lua (ao contrário de alternativas langauges incorporáveis ​​como Python andRuby).

Portabilidade. O núcleo Lua é compatível com ANSI C: o que significa que deve ser executado em praticamente qualquer sistema estes dias. Um grande esforço está indo para melhorar a Lua em microcontroladores.

Lua está licenciado sob a licença MIT, por isso há basicamente nenhuma restrição sobre a incorporação, derivados ou modificá-lo.O que não é tão excitante?

Conjunto limitado de bibliotecas padrão. Comparado com Perl ou Python, Lua tem muito poucos incorporado nas bibliotecas, e um conjunto razoável, mas não excepcional de bibliotecas de terceiros. As chances de sua biblioteca C favorito a ser obrigados a Lua são muito menos ...

No built-in threading. Determinista multi-tasking é totalmente suportado usando co-rotinas, mas se você quiser fazer uso de seus processadores, você precisa fazer uso de bibliotecas de terceiros que nem sempre podem ser tão estável.

Indexação de matriz começa a partir de 1. Uma característica herdada de seu fundo de descrição de dados, mas uma pegadinha para programadores vindo de um fundo em C ...

 

Lua é uma linguagem de programação poderosa, rápida e leve, projetada para estender aplicações.

Lua combina sintaxe simples para programação procedural com poderosas construções para descrição de dados baseadas em tabelas associativas e semântica extensível. Lua é tipada dinamicamente, é interpretada a partir de bytecodes para uma máquina virtual baseada em registradores, e tem gerenciamento automático de memória com coleta de lixo incremental. Essas características fazem de Lua uma linguagem ideal para configuração, automação (scripting) e prototipagem rápida.

 

Por que escolher Lua?

 

Lua é uma linguagem estabelecida e robusta

Lua é usada em muitas aplicações industriais (e.g., Adobe's Photoshop Lightroom), com ênfase em sistemas embutidos (e.g., o middleware Ginga para TV digital) e jogos (e.g., World of Warcraft). Lua é atualmente a linguagem de script mais usada em jogos. Lua tem um sólido manual de referência e existem vários livros sobre a linguagem. Várias versões de Lua foram lançadas e usadas em aplicações reais desde a sua criação em 1993.

 

Lua é rápida

 

Lua tem uma merecida reputação de ótimo desempenho. Outras linguagens de script aspiram ser "tão rápidas quanto Lua". Vários benchmarks mostram Lua como a linguagem mais rápida dentre as linguagens de script interpretadas. Lua é rápida não só em programas específicos para benchmarks, mas no dia-a-dia também. Porções substanciais de aplicações grandes são escritas em Lua.

 

Lua é portátil

 

Lua é distribuída via um pequeno pacote e compila sem modificações em todas as plataformas que têm um compilador ANSI/ISO C. Lua roda em todos os tipos de Unix e Windows, e também em dispositivos móveis (como computadores de mão e celulares que usam BREW, Symbian, Pocket PC, etc.) e em microprocessadores embutidos (como ARM e Rabbit) para aplicações como Lego MindStorms.

 

Lua é embutível

 

Lua é uma engine rápida e pequena que você pode facilmente embutir na sua aplicação. Lua tem uma API simples e bem documentada que permite uma integração forte com código escrito em outras linguagens. É simples estender Lua com bibliotecas escritas em outras linguagens. Também é simples estender programas escritos em outras linguagens com Lua. Lua é usada para estender programas escritos não só em C e C++, mas também em Java, C#, Smalltalk, Fortran, Ada, Erlang, e mesmo outras linguagens de script, como Perl and Ruby.

 

Lua é poderosa (e simples)

 

Um conceito fundamental no projeto de Lua é fornecer meta-mecanismos para a implementação de construções, em vez de fornecer uma multidão de construções diretamente na linguagem. Por exemplo, embora Lua não seja uma linguagem puramente orientada a objetos, ela fornece meta-mecanismos para a implementação de classes e herança. Os meta-mecanismos de Lua trazem uma economia de conceitos e mantêm a linguagem pequena, ao mesmo tempo que permitem que a semântica seja estendida de maneiras não convencionais.

 

 

Lua é pequena

 

Incluir Lua numa aplicação não aumenta quase nada o seu tamanho. O pacote de Lua 5.2.0, contendo o código fonte e a documentação, ocupa 241K comprimido e 950K descompactado. O fonte contém cerca de 20000 linhas de C. No Linux, o interpretador Lua contendo todas as bibliotecas padrões de Lua ocupa 182K e a biblioteca Lua ocupa 240K.

 

 

Lua é livre

 

Lua é software livre de código aberto, distribuída sob uma licença muito liberal (a conhecida licença MIT). Lua pode ser usada para quaisquer propósitos, incluindo propósitos comerciais, sem qualquer custo ou burocracia. Basta fazer um download e usá-la.

Lua tem importância global

O projeto e a evolução de Lua foram apresentados em junho de 2007 na HOPL III, a 3a Conferência da ACM sobre a História das Linguagens de Programação. Essa conferência ocorre a cada 15 anos (a primeira foi em 1978 e a segunda em 1993) e somente poucas linguagens são apresentadas a cada vez. A escolha de Lua para a HOPL III é um importante reconhecimento do seu impacto mundial. Lua é a única linguagem de programação de impacto desenvolvida fora do primeiro mundo, estando atualmente entre as 20 linguagens mais populares na Internet (segundo o índice TIOBE).

 

 

Entre na organização lua para saber mais.

 

 

Agora que já aprendemos uma noção de lua vamos fazer a meta , não sabe oque é meta?

O arquivo apresenta meta.xml MTA com um conjunto de metadados, como nome do recurso, os scripts para incluir, e quais arquivos para precache para enviar aos clientes entre outras coisas. É também o escopo de "elementos". É escrito em XML, que é baseado em HTML e é o pai do XHTML.

 

Saiba algumas linhas da meta

 

<info /> As informações sobre este recurso, os parâmetros possíveis incluem (qualquer parâmetros arbitrários podem ser utilizados e lidos usando getResourceInfo ):

 

autor: O autor deste recurso

 

versão: A versão deste recurso

 

name: O nome desse recurso

 

descrição: Uma breve descrição do recurso

 

Tipo: O tipo desse recurso, que pode ser "modo de jogo", "script", "mapa" ou "misc".

 

<script /> O código fonte para este recurso, os parâmetros possíveis são:

 

<MAP /> O mapa de um modo de jogo, os parâmetros possíveis são:

 

Vamos usar apenas algumas delas entre tanto há muitos comandos saiba mais deles aqui no entanto vamos apenas precisar desses comandos mais tarde. agora que temos alguns sintaxes

vamos usar os seguintes sintaxes : autor , descrição , Tipo , versão , name.

vale lembrar que a meta tem que ser inteiramente ingles

Então vamos começar a criar a meta

 

Vamos criar um arquivo xml ( não sabe criar um arquivo xml? clique aqui )

Quando criar o arquivo xml deve colocar este código

 

<meta>

<info author="SeuNome" type="TipoDoSeuRoteiro" name="NomeDoScript" description="Descrição" />

<script src="script.lua" />

</meta>

 

(Para Fazer a instalação do arquivo meta use o bloco de notas depois de feito os codigos use , Salvar Como

Meta.xml)

vale lembrar , que quaisquer script começa com functions NomeDoSeuScript ()

Então vamos começar a criar. nosso roteiro sera uma mensagem de boa vinda ao usuario entrar no servidor.

então vamos começar

 

function joinHandler()

 

outputChatBox("Em Bindo ao meu servidor", source)

end

addEventHandler("onPlayerJoin", getRootElement(), joinHandler)

 

Note que o roteiro começa com functions e dentro de outputChatBox , a sua mensagem. sempre outputChatBox é a caixa onde devemos por nossos textos e contextos. Agora vamos subir de nivel com esse roteiro vamos acrescenter bitagens de números , com éssas bitagens conseguimos mudar de cor então o novo código sera

function joinHandler()

 

outputChatBox("Em Bindo ao meu servidor" , source, 255, 255, 255)

end

addEventHandler("onPlayerJoin", getRootElement(), joinHandler)

 

Agora temos um roteiro inteiramente criado. agora vamos instalar no servidor, criando um arquivo no Meu Documentos ou no desktop dentro da pasta vamos juntar a pasta META e ainda não salvamos o seu script. entao façamos o seguinte após ter o código dentro do bloco de notas

function joinHandler()

 

outputChatBox("Em Bindo ao meu servidor" , source, 255, 255, 255)

end

addEventHandler("onPlayerJoin", getRootElement(), joinHandler)

 

clique em arquivo > salvar como > script.lua

 

agora pegamos o arquivo e fincamos junto com a META dentro da pasta criada. e logo após enviamos para

H:\Arquivos de programas\MTA San Andreas 1.1\server\mods\deathmatch\resources e colamos.

 

Vale lembrar que você deve arca com o sintaxe mal feito. e também vale lembrar que esse é um tutorial basico. para saber mais entre no site oficial do mta sa .

 

Creditos

MTABRASIL - Parte 1

GTGMODS - PARTE 2 MAIS DOS SINTAX DO MTA.

Eu - Pelo tópico. obter fix e mais coisas...

[luizcdd2 1]

Mega toturial

esta sem cores e prints

mais Obrigado por compartilhar ~