Essa função seria o “main” do C, ou “Main” do Java, isto é, uma função que é executada em primeiro lugar ao carregar o programa.
Veja o código em C:
|
1 2 3 4 5 6 7 8 |
#include<stdio.h> //inclui a biblioteca de entrada e saída. int soma(int a, int b){ return a+b; } int main(int argc, char **argv){ printf("123 + 110 = %d\n", soma(123,110) ); return 0; } |
(para compilar use: gcc -o teste teste.c )
Ao executar o código acima compilado, a função ‘main’ será executada automaticamente, executando, por consequência, as funções chamadas internamente nela.
Em Lua, da qual Prisma deriva, não há uma função main, para simulá-la, você deve fazer algo como:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
function printf(fmt,...) io.write(string.format(fmt,...)); end function soma(a,b) return a+b; end function main(...) printf("123 + 110 = %d\n", soma(123,110)); return 0; end return main(...); --devemos chamar explicitamente main em Lua! |
Agora veja em Prisma:
|
1 2 3 4 5 6 7 8 |
funcao principal(args) imprimaf("123 + 110 = %d\n", soma(123,110)); retorne 0; fim funcao soma(a,b) retorne a+b; fim |
Note que não precisamos chamar principal no final, Prisma faz isso automaticamente. Isso foi implementado por mim no interpretador em C.
Observe que há um único parâmetro (args) que são os parâmetros passados em linha de comando ao executar o programa. Trata-se de uma tabela em que args[-1] e o path do interpretador, args[0] é o programa prisma atual, e args[1] é o primeiro parâmetro e assim por diante.
Obs.: função imprimaf foi adicionada desde a versão 1.0.99
Temos algumas restrições quanto ao uso da função principal:
1 – Não a use como nome de variável, ela é unicamente para ser uma função.
2 – Sempre deverá ser uma função global. Se for declarada como local não será executada automaticamente, sendo necessário chamá-la igual em Lua.
3 – Podemos declarar funções após a função principal e chamá-las de dentro da principal desde que não sejam funções locais. Veja que o código abaixo geraria um erro:
|
1 2 3 4 5 6 7 8 |
funcao principal(args) mostre_ola(); fim local funcao mostre_ola() imprima("ola!"); retorne 0; fim |
A função mostre_ola é local, o que ocasiona um erro ao ser chamada de dentro da principal visto que ela foi declarada depois.
Felizmente há um modo de usarmos funções locais mesmo declaradas após à função principal, veja o exemplo anterior funcionando:
|
1 2 3 4 5 6 7 8 9 10 |
local mostre_ola; //declarando mostre_ola como local antes da principal, sem valor ainda funcao principal(args) mostre_ola(); retorne 0; fim funcao mostre_ola() //ainda continua sendo local. imprima("Ola mundo em Prisma!!"); fim |
Sabemos que variáveis locais são acessadas mais rapidamente dando eficiência ao programa, e funções locais são variáveis locais.
Para declarar várias funções locais antes da função principal() use vírgulas:
|
1 |
local soma, escrevaf, dobro, quadrado; |
Veja que todas serão locais, lembre-se de implementá-las após a função principal():
|
1 2 3 4 5 6 7 8 9 10 11 12 |
funcao soma(a,b) retorne a+b; fim funcao dobro(n) retorne n*2; fim funcao quadrado(n) retorne n*n; fim funcao escrevaf(fmt,...) es.escreva(string.formate(fmt,...)); fim |
Espero que tenha sido útil o post.
Até mais.