INTRODUÇÃO À LINGUAGEM PRISMA BR

 

 

Por Adalberto Amorim Felipe

 

 

fevereiro/2016

 

 

Introdução

 

Este material é para iniciantes, ou para quem tem dificuldades em adentrar nos conceitos técnicos da linguagem Prisma. Portanto, é para ser lido com paciência percorrendo em detalhes a linguagem, ou para ser consultado na parte que mais interessa. Ele começa bem do básico mesmo e a tendência é ir ao avançado, espero que seja útil.

 

Em primeiro lugar você deve conhecer alguns aspectos sobre a linguagem Prisma:

 

O que é Prisma?

 

É um conjunto que inclui:

1 – linguagem de programação e suas regras de comandos;

2 – interpretador;

3 – bibliotecas e arquivos externos.

Vejamos cada item anterior:

linguagem de programação e suas regras de comandos:

Digamos que qualquer linguagem possa ser inventada, basta você determinar as regras, as palavras reservadas funções da biblioteca padrão, enfim, o modo como escrevê-la, os símbolos permitidos e para que servem, o que pode e o que não pode.

É exatamente as regras e mecanismos de funcionamento da linguagem que você deve dominar para fazer os programas, os aspectos da linguagem. Esses aspectos são a essência da linguagem e Prisma tem isso, podemos citar uma característica importante dela que possui comandos em português ao invés do inglês que é de costume.

Definidos teoricamente os aspectos da linguagem, basta criar um meio de fazê-la funcionar, afinal, não queremos algo na teoria somente mas na prática também.

Interpretador:

Diversas linguagens possuem como mecanismo de execução a compilação do código-fonte para código nativo do processador.

Prisma é diferente, ela possui um mecanismo de interpretação, isto é, há o programa feito em C que interpreta os comandos do código-fonte ou código-byte. O interpretador pode ser chamado da seguinte forma por linha de comando:

prisma.exe programa_prisma.prisma, na sequência temos o carregamento do arquivo fonte chamado ‘programa_prisma.prisma’ que é convertido internamente para byte-codes (códigos em bytes) e após isso é executado. Pode-se, ainda, compilar o código-fonte do programa prisma para byte-codes usando o prismac, seu modo de chamar é:

prismac -o programa_compilado.pbrexe programa_fonte.prisma, será gerado um arquivo binário chamado

programa_compilado.pbrexe.

Mas o que é programa fonte, ou código-fonte? Simples, todo programa em linguagem de alto-nível é escrito, isto é, o

programa é feito em frases, geralmente frases no imperativo, por exemplo, escreva ‘ola’, x = leia ( ); ig.feche ( );

estas frases devem seguir as regras da linguagem. Portanto o código fonte é o arquivo texto que contém as frases dos comandos do programa que se quer fazer. O prismac.exe converte esse texto para código byte, isto é, as instruções (frases) são traduzidas para zeros e uns (bytes) cuja organização pode ser compreendida e interpretada pelo prisma.exe ( o interpretador );

Enfim, o interpretador é o que torna a execução de um programa prisma possível, sem ele não há como executar os programas feitos nesta linguagem. Várias outras linguagens são assim, podemos citar Python, C#, Java, Ruby, Lua, Lisp, Php entre outras. O fato de uma linguagem ser interpretada garante algumas vantagens e perde outras, perde principalmente no uso da memória e velocidade, mas ganha em portabilidade e simplicidade na criação dos softwares.

Prisma é, na verdade, uma modificação dos fontes de Lua, uma linguagem brasileira de fama internacional muito usadas em jogos, pois é das linguagens de scripts a mais veloz e leve. Como Prisma tem nela sua origem herda esses traços, sendo mais leve que Java, por exemplo, mais simples de se aprender que Python. Prisma tem um enorme potencial que se encontra no fato de quase tudo feito em C pode ser estendido a Prisma. Por exemplo, é simples implementar funções do gtk em Prisma, assim como em Lua.

Bibliotecas e arquivos externos

Nem todo recurso necessário será encontrado no interpretador Prisma diretamente. Por exemplo, se você quiser fazer um programa com janelas e botões, não conseguirá fazer isso somente em prisma, deverá usar funções gráficas que estão em outro programa chamado igbr, que é uma biblioteca em prisma.

Bibliotecas servem para isso, criar funções que ainda não existem em prisma estendendo novas funcionalidades. Inclusive, você pode criar novas bibliotecas, seja na própria linguagem Prisma ou em C. As bibliotecas chamadas também de módulos podem ter as seguintes extensões: .pris para módulo em prisma (ou _pris.dll ) , e .dll para módulos nativos em C. (para módulos em C é necessário saber programar em C e compilar dlls);

( Em linux essas extensões podem alterar para _pris.so e .so );

Adiante veremos com detalhe como fazer suas próprias bibliotecas.

Por fim, você precisa saber que para programar em Prisma deve estudar a linguagem – a parte do manual que trata da linguagem em si. Já para programar com um tipo específico de biblioteca precisa estudar sobre a biblioteca a ser usada, seja ela um módulo de funções gráficas, base de dados, ou network, etc.

Aqui, mais especificamente, veremos sobre a linguagem em si!

 

 

 

 

 

Unidade I – Introdução à linguagem

 

 

 

Cap. 1 – Primeiro programa: função imprima() e leia() , strings, números e comentários –

 

Caso não tenha instalado prisma vá para a página de downloads e primeiros passos.

 

Vamos programar então:

Com o editor aberto, crie um arquivo, salve-o com o nome de ola.prisma em uma pasta de sua escolha e digite o seguinte comando dentro dele :

 

Execute-o pressionando o botão executar que se encontra na barra de ferramentas do prismacod ou no menu ferramentas->executar.

Sim, uma única linha aqui já é um programa, que exibe a mensagem Ola mundo em prisma! na janela de comandos.

Vejamos, você aprendeu aqui uma função imprima (que imprime “frases na tela”), esse texto entre aspas é chamado

em programação de string, que em inglês significa corda ou cadeia, ou seja, no sentido de sequência de caracteres.

O interpretador não interpreta nada do que está dentro de uma string, ela é tratada como um objeto que se pode

manipular e ser exibido na tela.

 

A função imprima dispensa o uso do parênteses, assim como qualquer outra função, na condição de que tenha um único parâmetro e seja uma string (Tabelas como parâmetro único também dispensam o uso de parênteses ).

 

reescreva o comando anterior da seguinte forma:

 

tente agora:

 

Deve ter notado uma grande diferença, cada trecho saiu em uma linha diferente, isso foi devido ao \n que é chamado de caractere de escape nova linha, quando há um desses dentro de uma string ele não é impresso, ao invés disso o texto vai para linha seguinte. Há diversos caracteres de escape, vejamos quais são eles:

---

 

Sequências de escape em Prisma:

\a – campainha (dá certo só no Windows):

 

\n – nova linha:

 

 \b – backspace (apaga um caractere anterior):

 

 \f – avanço de página:

 

 \r – Retorno do carro (volta para o inicio da linha):

 

 \t – tabulação horizontal:

 \v – tabulação vertical:

 

 \’ – aspas simples:

 

 \” – aspas duplas:

 

 \\ – barra invertida:

 Usando tabela ASCII: \nnn  (preencha com zero à esquerda)

 

Tabela ASCII em hexa decimal: \xhh

 

---

 

Alguns detalhes:

Note que na frente do comando escrevemos duas barras oblíquas // e em seguida uma frase. Essas barras indicam que o que estiver depois delas até o fim da linha não deve ser interpretado, logo, o interpretador ignora esta parte do programa, isto é chamado de comentário, eles são muito úteis em programas de grande porte onde você deve lembrar para que serve cada comando criado, descrevendo explicações nos comentários.

Outra forma de fazer comentários é usando a sequência /**( para abrir) e ** (para fechar), com isso pode-se criar comentários de várias linhas sem precisar colocar as // em cada uma delas, ex.:

Atenção: a partir da versão Prisma-1.0.99 o comentário multilinha foi modificado:

Para abrir use /*    e para fechar  */

A função imprima pode mostrar não só textos entre aspas como também números diretamente, veja:

 

Tente este outro comando:

 

 

obs. tente mudar os números e a operação, os sinais básicos de matemática são: / divisão, * mutilplicação, + soma, – subtração.

Note que prisma primeiro executa a operação entre parênteses até obter um único resultado para depois imprimir na tela.

Dica: no final de cada comando coloque um ponte-e-vírgula para separar uns dos outros, veja:

 

Sem os pontos-e-vírgulas, a execução quase sempre acontecerá sem erros, mas é bem mais organizado com o uso do ponto-e-vírgula.

 

Até agora aprendemos a mostrar textos e números na janela de comandos (tela preta);

Vejamos uma função diferente do imprima (), a função leia(), veja:

 

 

Note que ao executar, o cursor ficou piscando dentro da tela de comandos do windows ou terminal do linux, esperando você digitar algo. Ao digitar e apertar a tecla Enter o resultado ficou gravado na palavra x, e depois é impresso com a função imprima.

Esse efeito de gravar um resultado em um nome é chamado de atribuir uma variável (no caso o x, mas poderia ser qualquer outro nome ), veremos sobre variáveis mais adiante.

Talvez você tenha notado que usamos uma vírgula dentro da função imprima desta vez, isso é porque temos dois argumentos colocados dentro da função, primeiro o texto : “Voce digitou : “ e segundo a variável x, então a função mostra o texto e na sequência o que está armazenado em x; Veja que não é impresso o x mas o valor que foi digitado, este é o conceito de variável.

Obs. Note que variável é um nome criado sem aspas, tudo o que tiver entre aspas geralmente é uma string.

Obs. Strings em prisma podem ser feitas de outras duas maneiras além do uso de aspas duplas:

1 – usando aspas simples :

 

2 – usando duplos colchetes, permitindo uma string multi-linha, não aceita caracteres de escape, se tiver algum ele será impresso

na tela como uma string:

 

Há outra forma de fazer strings multilinhas:

Para esse estilo dar certo é necessário, após a barra, o fim da linha. Para isso pressione enter após ela, caso tenha um único espaço, não dará certo. Note que o mesmo sinal que abriu a string (“) no início, é o que fechou no final (“).

 

 

 

 

Cap. 2 – Palavras reservadas, operadores relacionais e lógicos

 

 

Anteriormente, nós vimos que além de outras coisas, uma linguagem é composta por palavras reservadas, mas o que será isso?

Palavras reservadas: são palavras comando da própria linguagem, não podendo ser usadas com outro propósito:

Português // inglês:

 

Não se preocupe em decorá-las, você aprenderá a usá-las no decorrer dos estudos, só estão listadas aqui para ilustração.

Note que devemos usar a palavra-chave tal como ela se apresenta, ex:

use o se e não SE ou Se ou sE, Prisma é case sensitive, isto é, diferencia maiúsculas de minúsculas.

Palavras reservadas e funções são coisas diferentes, as palavras são fixas e imutáveis, a não ser,

que se modifique a própria linguagem, já as funções podem ser criadas modificadas e atribuídas. logo:
‘enquanto’ é de categoria diferente de ‘imprima’ ( uma é palavra-chave e outra função );

————————————————————————

Além das palavras reservadas, temos os sinais e suas funções específicas dentro da linguagem.

Sinais especiais e operadores relacionais:

 

obs.: Quando usar os sinais compostos jamais deixe espaço entre eles, ex.:

( < = //errado ) ( <= //certo )

veja o uso deles respectivamente:

concatenar strings / argumentos indefinidos para funções / testa igualdade / maior ou igual a /

menor ou igual a / diferente de / menor que / maior que

Exemplos de como usar:

‘..’ (Dois pontos seguidos)

 

———————————————————————————————-

‘…’ (Reticências)

Se não conseguiu entender completamente os … não tem problema, o veremos mais adiante, e além disso, não são muitas as situações que você precisará usar no momento.

 

---

Agora os operadores relacionais:

( são muito úteis para testes de condições, retornam verdadeiro ou falso)

veja:

 

Operadores lógicos : ou , e , nao

 

(em especial, dê uma atenção ao operadores lógicos, verá o quanto será recompensador, pois problemas complexos serão facilmente resolvidos com o uso de um operador lógico, ok!)

ou :

O ou retorna o primeiro valor válido dentre vários, ou então nulo caso nenhum seja válido, muito útil para testar se uma variável já existe e atribuir ou não um valor a ela. Veja:

Interprete assim: x é igual ao próprio x se ele já tiver valor ou a 1 se ele ainda não tem valor, isto é, se é igual a nulo.

 

Você pode colocar vários operadores ‘ou’ em sequência, veja:

 

————————————————————————————————————————-

Se você testar vários valores e todos forem nulo, o retorno é nulo.

Se você testar vários valores e um for falso e o restante for nulo, então falso é atribuído, veja:

---

 

 

O ou pode ser usado em testes de condições com o comando ‘se’ que veremos mais adiante, veja:

 

e :

o operador ‘e’ retorna o primeiro valor inválido ( falso ou nulo), caso contrario retorna o próximo até encontrar um nulo ou falso.

 

 

 

Caso não tenha nenhum valor inválido o último valor é retornado, veja:

Podemos usar o operador ‘e’ em um teste de condição, neste caso ambos os valores devem ser válidos para a condição ser satisfeita:

 

 

nao :

 

O operador lógico ‘nao’ é unário isto é não exige dois valores para a operação, apenas um, antecedendo-o, veja:

 

Este operador retorna verdadeiro ou falso:

Caso o valor seja válido, ele retorna o oposto, ou seja, falso.

Caso o valor seja inválido, isto é, se o valor for nulo ou falso, ele retorna verdadeiro;

ex.:

 

É muito útil em condições:

Caso haja um erro ao tentar abrir o arquivo o retorno é nulo. Sendo nulo o operador nao retornará o contrário, isto é, verdadeiro. Assim a condição é satisfeita e a mensagem de erro é impressa.

 

 

 

 

Cap. 3 – Variáveis, tipos e a função tipo()

 

 

Ao se trabalhar com uma linguagem de programação temos que saber quais são os tipos suportados, isto é, que dados podem ser usados nesta linguagem. Já vimos dois tipos de dados nos primeiros programas, o tipo string “texto entre aspas” e o tipo número 1000000 por exemplo.

Dados podem ser ‘apelidados’, para que ao invés de passarmos o dado em si, passemos o apelido que é chamado de variável em programação. Por exemplo, se quisermos chamar o valor 1200.00 de salario, então salario será a variável que pode ser atribuída da seguinte forma: salario = 1200.00, o ‘=‘ é o operador de atribuição. Podemos mudar o valor de uma variável bastando reatribuir outro valor, veja: salario = 2000.00, desta forma onde usarmos a palavra salario, será passado o valor atribuído a ela, ex.:

---

Variáveis

O que são variáveis afinal? São nomes criados pelo programador para simbolizar um dado dentro da linguagem. Geralmente a variável representa o endereço na memória do valor atribuído.

Dica:

Uma variável pode ser criada com qualquer nome que não seja uma palavra reservada, no entanto, devemos seguir alguns critérios:

1- nunca inicie o nome de uma variável por número ou dígito, gerará erro. Pode iniciar por Underline (sublinhado) ou letra.

2- Escolha nomes que têm algo a ver com o dado armazenado, ex.: gasto = 10.00 ; lucro = 100.00 ao invés de n1 = 10.00; n2 = 100.00, visto que no primeiro caso ficou muito mais fácil entender sobre o que se trata o dado.

3 – Se for um nome composto use iniciais maiúsculas, ex.: NomeDoCliente = “Marcos”; ou separados por sublinhado, ex.: nome_do_cliente = “Marcos”, fica muito mais legível do que nomedocliente ;

4 – Cuidado para não sobrescrever um valor de uma variável já existente, ex.: imprima = “nome do comando”; se depois disso você tentar usar a função imprima( ) verá que ela não funciona mais, pois você reatribuiu o valor da variável imprima. Sim é claro, funções são tipos de variáveis em Prisma.

 

Variáveis em Prisma não possuem tipos fixos, são tipadas dinamicamente, ou seja, não é necessário declarar qual tipo uma variável irá armazenar ( como é feito em C por exemplo: int x = 12; ), basta inicializá-la, ex:

 

Note que ao atribuirmos um novo valor a uma variável já existente, o valor antigo se perde e o novo fica em seu lugar!

*Em Prisma variáveis não têm um tipo fixo, mas o dado sim carrega seu próprio tipo, Prisma sabe que um número é um número e não uma string ou vice-versa, por exemplo.

Se você é iniciante em programação, deve ter um pouco de dificuldade em assimilar o conceito de variável de início. Não se preocupe, você vai dominar o conceito conforme o tempo de estudo, o que em Prisma não é tão demorado, visto a sua simplicidade.

Apenas saiba que usamos o sinal de ‘=’ para atribuir um valor que está à direita do sinal a um nome à esquerda do sinal, este nome passa a carregar este valor atribuído.

 

Em Prisma podemos atribuir diversos valores para várias variáveis ao mesmo tempo, usando a vírgula, veja:

 

Caso sobre uma variável, o valor daquela que sobrou será nulo, veja:

 

Se o número de variáveis for menor que o número de valores atribuídos, os valores extras são perdidos, veja:

 

---

Tipos de dados

 

Diferentemente de outras linguagens que têm muitos tipos de dados, em Prisma o número deles é bem reduzido, o que favorece a rapidez do aprendizado. Bom, vejamos os dados em Prisma:

número, string , tabela, funcao , userdata, boolean, nulo;

obs.: para sabermos o tipo de um dado existe a função tipo ( ); ex.: imprima ( tipo( 5 ) ) ; //saída é ‘numero’

 

Agora analisaremos cada um deles com exemplos, se possível tente assimilar ao máximo o conceito e utilidade deles:

 

 

numero

É qualquer número, não diferencia entre decimal e inteiros.

ex:

Obs. não use virgula para separar as casas decimais, em programação é usado o ponto para isso, ok!

string

 

Qualquer sequência de caracteres entre aspas simples ou duplas, ou entre duplo colchetes(multilinha);

ex:

 

 

tabela

 

Poderoso recurso para manipulação de dados em massa, nada mais é do que uma variável que armazena mais de um valor ao mesmo tempo e esses valores ficam guardados em subdivisões dentro da tabela através de índices ou campos. Não é necessário declarar o tamanho da tabela como na maioria das linguagens.

Obs.: Tabelas podem ser conhecidas como vetores, matrizes, arrays etc. em outras linguagens.

ex.:

 

 

é possível fazer uma matriz de componentes facilmente em prisma:

 

cria quatro botões; ( botao[1], botao[2] … etc.)

 

Tabela é um recurso tão poderoso que podemos

armazenar qualquer valor válido, inclusive funções:

 

 

Um array associativo de uma função funciona como um método de console. Veja:

 

Obs.: lembre-se que o ponto separa o nome da tabela de seu campo.

 

Poderíamos fazer uma função que passasse a própria tabela como parâmetro padrão “este”:

 

Ao usar dois pontos ‘:’ passamos a própria tabela na variável reservada ‘este’. Portanto, este.versao é o mesmo que console.versao.

A partir da versão Prisma-1.0.99 (2017) é possível usar também os sinais  -> para acessar um método veja:

Fica optativo, use qual preferir: os ‘:’ ou ‘->’

Obs.: ‘este’ é uma variável reservada, não podendo ser usada de outra forma.

função

São trechos automatizados de rotinas de execução, funções podem ou não receber parâmetros e retornar valores, são muito úteis para organizar o programa em sub blocos executáveis.

ex.:

 

Funções em Prisma podem retornar mais de um valor:

Se uma função retornar mais de um valor e você se esquecer de colocar mais de uma variável à esquerda do ‘=’ , só o primeiro valor será atribuído os demais se perderão.

Userdata

 

É um tipo de dado que armazena um ponteiro para um uma variável do programa compilado em C; Só é utilizado para acessar dados e funções em Prisma da linguagem C. ex: ao usar a função jan = ig.janela( ) o retorno é um endereço de um ponteiro GtkWindow em C.

 

Boolean

 

Armazena apenas dois valores: falso e verdadeiro ( em inglês: false , true );

ex:

 

Nulo

 

É qualquer valor inexistente, vazio. Ex.:

Obs.: nulo é considerado falso em testes de condição em Prisma, ex.:

Para matar uma variável basta atribuir a ela o valor nulo:

 

 

 

Cap. 4 – Escopo das variáveis

 

O escopo pode ser: global ou local.

Em Prisma, qualquer variável declarada é global, isto é, seu valor pode ser usado em qualquer parte do programa ou dos módulos do programa principal.

Já a variável de escopo local ao ser declarada deve ser antecedida pela palavra reservada local ex.:

Deste modo este tipo de variável não é visível fora do bloco ao qual pertence. O bloco pode ser uma função, um laço condicional ou de repetição, um bloco simples ou um programa Prisma.

A vantagem em se declarar uma variável local é a segurança para que ela não seja modificada por uma função externa acidentalmente, ou em caso de dúvidas ao atribuir variáveis com mesmo nome.

Para entender melhor vejamos os exemplos:

 

O resultado será: Ola! nulo

A segunda variável é local por isso não é visível fora da função inicie_var ( ) e seu valor fora dela é inexistente: nulo.

 

Para controlar o escopo das variáveis sem precisar fazer uma função toda vez, podemos criar um bloco de comandos com as palavras reservadas inicio fim, veja:

 

 

Cap. 5 – Controle de fluxo e laços de repetição

(se, enquanto, repita, para)

 

Ao escrever um programa podemos querer que ele tome decisões, por exemplo, fechar o programa se o usuário digitar ‘S’ ou executar repetidas vezes uma função até chegar ao fim de um arquivo.

Enfim, para isso existem os laços de controle e repetição. Esses comandos são tão necessários que qualquer linguagem os possui, e com Prisma não é diferente.

Para exemplificar tomemos o primeiro exemplo acima, fechar o programa ao digitar ‘S’.

Usando o comando ‘se’ :

 

A estrutura básica é: se condiçao entao …código… fim

Não esqueça de fechar o comando se com um fim respectivo. Não se esqueça de usar a palavra entao depois da condição.

Se o usuário digitar o S ou s o programa é fechado imediatamente.

Note que mesmo o usuário não digitando nada o programa não tem muito o que fazer depois, e logo fecha.

 

Colocando uma exceção para o comando se, usando o ‘senao’:

 

Estrutura básica é: se condição entao …código… senao …código da exceção… fim

 

Neste caso se a verificação numero < 0 retornar verdadeiro a primeira função imprima será executada, caso ela retorne falso a função depois do senao será executada, é fácil entender, interprete desta maneira: se numero digitado pelo usuário for menor que zero realiza a primeira opção senão realize a exceção que é o segundo imprima.

usando o ‘se’ o ‘senaose’ e ‘senao’:

Estrutura básica:

se condição entao …código… senaose condição entao …codigo2 … senao …exceção… fim

Pode-se omitir o senao e usar somente o fim se não quiser nenhuma exceção, ficando assim:

se condição entao …código… senaose condição entao …codigo2 … fim

 

O senaose é justamente para testar uma série de condições subsequentes, caso uma delas seja verdadeira, o código do seu corpo é executado e as demais ignoradas. Veja um exemplo:

 

Comando enquanto

 

Repete um bloco enquanto o retorno da condição for verdadeiro, sua estrutura básica é:

enquanto condição inicio

….código …..

fim

Exemplo:

 

 

usando o comando quebre:

 

Se preferir você pode fazer um laço enquanto infinito e controlar a repetição por dentro do laço usando o quebre:

 

Ao usar quebre o laço é interrompido imediatamente.

 

 

Comando repita

 

Seu funcionamento é semelhante ao enquanto, repete um bloco até que a condição seja verdadeira.

Sua estrutura básica é:

repita …. comando … ate condicao

Outro exemplo imprimindo de 1 a 1000:

Comando ‘para’ (numérico)

 

Obs.: este modelo é chamado de numérico porque consiste na repetição de um número inicial até um número final.

Este comando também serve para repetição. Ao contrário dos demais, nele é preestabelecido o número de repetições no próprio cabeçalho do comando. Para entender melhor veja:

Estrutura básica: para var_inicial, var_final inicio ….comandos …. fim

ex.:

Veja que o comando em si é bem simples, leia o exemplo acima da seguinte forma:

para o valor inicial de i que é 1 incremente até chegar ao valor 1000 ;

Note que i é uma variável local ao bloco do comando para, poderia ser um nome de sua escolha (desde que válido, lembre-se das regras ao declarar uma variável em Prisma) – ex.: para cont = 1 , 1000 inicio …código… fim;

Este primeiro exemplo foi o modo simples, existem outros modos do comando para, não se preocupe, veremos todos eles com calma, você dominará cada um aos poucos.

Adicionando o terceiro parâmetro no comando para, o incremento:

 

As vezes você pode querer que a repetição seja de 2 em 2 ao invés de 1 em 1, neste caso devemos usar um terceiro parâmetro no comando para, o incremento; o qual foi omitido no primeiro exemplo. Veja:

Estrutura básica – para var_inicial , var_final , incremento inicio …comandos… fim

 

Obs.: o número 2 é o tipo de incremento que significa o acréscimo de 2 ao valor de i a cada repetição, teremos então na execução: 1 3 5 … e assim por diante sempre somando 2 . Poderia ser outro número de sua preferência, por exemplo se quisesse contar de 10 em 10 deveria usar 10 no lugar de 2.

Note que ao omitir o terceiro parâmetro o valor padrão é 1.

Nunca use o sinal de mais ‘+’ para o incremento, ou gerará erro! Veja que os exemplos do comando para aqui são simples, apenas imprimem o valor do incremento a cada repetição, mas você pode adaptar e colocar qualquer comando válido no bloco de repetição, visto que o comando para é muito poderoso em determinadas tarefas, veremos mais adiante.

Determinando um decremento

 

Em algumas situações você vai preferir que o comando para inicie em um valor alto, 100 por exemplo, e diminua até chegar ao valor mínimo: 1 ou 0, por exemplo.

Veja:

Estrutura básica – para valor_maximo, valor_minimo , decremento inicio … código … fim

Note que usamos o sinal de menos para o decremento. O valor do decremento foi -1, isto é, diminui 1 de i a cada repetição, mas poderia ser outro valor como -2, -3 ou -10, para diminuir 2, 3 ou 10 de i a cada repetição, isso depende do propósito do programa e do programador.

Comando ‘para’ no modo especial (genérico)

 

Trata-se de um modo bem específico de uso do comando para em que usamos iteradores especiais (funções de incrementos que percorrem algum tipo de dado em sequência).

Primeiro modo, lendo os índices de uma matriz:

Estrutura básica – para var_indice , var_valor em ipares( matriz ) inicio … código … fim

Note que indice e valor são variáveis locais que receberão valores da tabela a cada repetição. A função ipares() percorre os índices e valores de uma tabela em Prisma. Note também que não usamos a vírgula no cabeçalho do comando para ao invés disso usamos a palavra reservada em.

(ipares vem de índice pares.)

 

Este exemplo do para genérico funciona muito bem em matrizes que possuem apenas índices numéricos, mas não funciona quando o índice é um campo, por exemplo, matriz [ ‘nome’ ] = ‘Amanda’; no exemplo acima não imprimiria Amanda, somente as chaves numéricas.

Não se preocupe! Para isso temos outra função: o pares. Simples, não é?

veja:

estrutura básica – para chave , valor em pares (tabela) inicio …comandos … fim

Note que a tabela criada no exemplo acima é mista, ou seja, possui valores indexados de forma numérica e pares de campo com valor, ainda incluímos um novo campo depois da criação da tabela dados.

Veja que a atribuição de chave/valor na função pares( ) vai na ordem de índices numéricos ( na sequência 1-2-3 …) para depois os campos. Estes são impressos na sequência de criação.

 

 

 

 

 

Cap.6 Funções

 

Em Prisma podemos dizer que função é uma variável especial que pode executar um bloco de código ao ser chamada, além disso, ela pode receber, manipular e devolver valores. Em outras linguagens, às vezes, são chamadas de procedures ou sub-rotinas.

Enfim, na prática temos um programa bem organizado se utilizarmos funções da forma correta do que um arquivo com um enorme emaranhado de comandos.

Para fazer uma função usamos a palavra reservada funcao, veja:

Estrutura básica – funcao nome ( parâmetros ) …códigos… fim

Note que a função é bem simples, não recebe parâmetro nem retorna dados, apenas imprima a frase Ola Mundo.

Como funções em Prisma são variáveis, existe um outra forma de fazer a função acima, veja:

 

Definindo parâmetros

 

Veja, o mesmo exemplo acima, mas modificado para receber um valor e imprimir esse valor:

 

No exemplo acima nós definimos um parâmetro para a função escreva, criando uma variável entre os parênteses, sendo assim essa variável é local, isto é, só pode ser acessada no bloco da função.

Dentro do corpo da função usamos a função imprima para imprimir o argumento passado para a função escreva.

Obs. Nunca coloque ponto e vírgula após fechar o parênteses da função. ( funcao ( msg ); // errado )

Devolvendo valores com o comando retorne

 

Além de receber valores uma função pode retornar valores, veja:

 

Observe que uma função pode receber muito mais do que dois parâmetros

Dica – sempre nomeie as funções de acordo com a tarefa que elas realizam, isso ajuda a ler e entender um programa futuramente.

Ex.: raiz_quadrada ( ) ; le_texto ( ) ; dobro ( ) ; etc.

 

Uma vantagem em Prisma é que uma função pode retornar mais de um resultado ao mesmo tempo, isso é feito por meio do uso de vírgulas. Veja:

Veja que para cada retorno deve haver uma variável à esquerda do operador de atribuição ‘=’, e cada variável deve estar separada por vírgula.

Caso um parâmetro fosse omitido ao chamar a função, o segundo parâmetro ficaria com valor nulo, veja:

valor1 , valor2 = maior_para_menor ( 9 ) ; //n2 na função não foi passado então seu valor é nulo. E isso ocasionaria um erro interno na função, pois ao tentar concatenar nulo ou executar uma operação com valor nulo, o programa falha e uma mensagem de erro é exibida.

E se o número de variável não for igual ao número de retorno?

valor = maior_para_menor ( 1, 2 );

Neste caso somente o primeiro retorno foi passado para a variável valor, o segundo retorno foi descartado!

Se o número de argumentos passados for maior do que os parâmetros exigidos pela função, os argumentos extras são descartados.

 

Recursividade em funções

 

Este efeito é obtido quando uma função chama a si mesma. Não é muito recomendado usar este recurso pelo perigo de erro difícil de ser detectado, e pelo simples fato de o mesmo poder ser feito de outra forma mais segura.

Veja, a função chama a si mesma e soma à variável um valor que é o retorno da própria função com o parâmetro igual a ela mesma menos 1 várias vezes até chegar a zero:

 

Note que a sequência de impressão na tela é: 0 1 3 e 6; em cada linha. Isso ocorre porque a função busca um resultado em seu retorno até chegar a zero, então de trás para frente ela vai somando os resultados.

Para entender, imagine ao passar o número 3 todo o processo que a função faz:

1 – função soma é chamada com o parâmetro numero 3:

compara 3 com 0 não é igual, entao: valor é igual a valor + soma ( 3 – 1 );

2 – função soma chamada novamente mas com o parâmetro número 2 ( que é o resultado de 3 – 1);

compara 2 com 0 não é igual então: valor é igual valor + a soma ( 2 – 1 );

3 – soma é chamada novamente de dentro dela mesma com o valor 1 ( resultado de 2 -1 )

compara 1 com 0 não é igual então: valor é igual a valor + soma( 1 – 1 );

4 – soma é chamada novamente com valor 0 como parâmetro ( resultado de 1 – 1 )

compara 0 com 0, é igual então retorna valor que é 0;

ao chegar ao resultado zero, todas as chamadas da função soma vão retrocedendo o valor somando o último com o anterior, 0 + 1 + 2 + 3 chegando no resultado final 6, por isso na tela apareceu os números nesta ordem:

 

Como dito antes não é recomendado o uso da recursividade pelo fato de que as possibilidades de gerar um erro oculto são maiores, e porque o mesmo resultado pode ser obtido de uma outra forma mais segura. É totalmente dispensável o uso da recursividade, até mesmo pela sua complexidade.

Veja a função anterior de outra forma mais segura:

Veja que o comando para torna a recursividade obsoleta, sem necessidade.

 

Uma detalhe ao se falar de funções é que quando o único argumento for uma string ou tabela, podemos dispensar o uso de parênteses, veja:

 

 

Além de tudo que vimos acima sobre funções, um aspecto interessante é que elas podem ser passadas como argumentos para outras funções ou retornar funções, veja:

 

 

 

Número indefinido de parâmetros em funções

 

Lembre-se da função imprima() que pode receber um, dois, três, ou indefinidamente mais parâmetros (claro que não infinito). Para fazermos isso em Prisma usamos o sinal de reticências ‘…’ dentro dos parênteses no cabeçalho da função. Veja:

 

Veja que os ‘…’ representam o número variado de argumentos que podemos colocar entre chaves e com isso criar uma tabela com todos os argumentos passados, não importa se um ou cem ou mais.

Veja a saída no modo prompt do interpretador:

Prisma 1.0.9 Interpretador Prisma por <adalbermirom@gmail.com>
Seja Bem-vindo! Tente digitar algum comando como: imprima(‘Ola, Mundo!’)

>>> funcao some_todos ( … )
… local tabela_num = { … };
… local tmp = 0;
… para i = 1 , #tabela_num inicio
… tmp = tmp + tabela_num[i];
… fim //fim para
… retorne tmp;
… fim //fim funcao
>>>
>>> imprima( some_todos( 2 , 3 , 5 ) );
10
>>> imprima( some_todos( 2 , 3 , 6, 54, 32 , 556 , 7) );
660
>>>
>>> //não importa se é um ou cem argumentos passados,
>>> //a funcao retornará a soma de todos.

 

Cap. 7 Operador de tamanho e operadores aritméticos

 

São eles:

# (tamanho)

* (vezes), / (divisão) + (soma) , – (subtração) , % (resto) , ^ (elevado a);

 

---

Veja como usar cada um deles:

#

(determina o tamanho de strings e tabelas) :

 

 

 

 

Operadores matemáticos ( servem para fazer operações aritméticas):

 

Mais adiante veremos a biblioteca ‘mat’ com funções especiais para matemática e trigonometria;

 

 

 

 

 

 

 

 

 

Unidade II – Biblioteca padrão

Introdução

Prisma, assim como outras linguagens, possui funções predefinidas, e que ficam organizadas em conjuntos chamados de biblioteca. Bibliotecas, também chamadas libs, podem ser internas ou externas.

As internas são as embutidas no interpretador Prisma, e por isso não precisam ser importadas com o comando ‘inclua’.

Todas as outras bibliotecas externas que precisam ser incluídas não são predefinidas, portanto é necessário carregá-las na execução do programa prisma.

Bibliotecas são importantes pois potencializam o poder da linguagem, é com suas funções que é possível escrever programas mais complexos.

Aqui serão tratadas o conjunto de biblioteca padrão, isto é, somente as internas, são elas:

base, string, mat, sis, es, tabela

A biblioteca “win” com funções da api do Windows fica em um tutorial separado, clique aqui para acessar.

---

Cap. 1 – Funções da biblioteca base

São as funções simples tais como a imprima( ) ; tipo ( ) entre outras. Elas não seguem o modelo das demais que usam o nome da biblioteca e o ponto separando o método.

Veja as funções e seus exemplos de uso:

imprima ( … )

Exibe na tela preta do cmd no Windows ou terminal no Linux texto ou números. Podemos passar vários argumentos de uma só vez separados por vírgulas;

ex.:

Note que com a barra invertida ‘\’ é possível passar o código e a saída será o caractere correspondente ao código numérico

Note também que \n faz a impressão ir para linha seguinte.

---

leia ( )

Uma versão simples do es.leia( ) (que trataremos adiante), a função leia aguarda o usuário digitar algo e retorna o que foi digitado, podendo ser armazenado em uma variável do seguinte modo:

tipo ( valor )

Esta função retorna uma string descrevendo o tipo de valor. Muito útil para sabermos qual tipo de variável é um dado. Valor pode ser uma variável ou diretamente um valor. Exemplos de uso:

---

Aproveitando aqui veja algumas variáveis predefinidas importantes:

 

* _versao – variável que guarda a versão de prisma, tente executar: imprima( _versao );

* prismadir – variável que guarda o diretório do executável prisma: imprima ( prismadir );

OBS – prismadir não funciona no Linux se o interpretador estiver no diretório bin.

* args – é uma tabela dos argumentos externos passados como parâmetros em linha de comando:

---

Voltando para as funções da biblioteca base

poe ( string )

Vêm do verbo pôr (poe, inglês = put ), coloca na tela preta o resultado, é o mesmo que a função imprima, mas com limitações, não aceita por exemplo mais de um argumento, é bom para strings apenas. Ex.:

executestring( string )

Executa um trecho de comando em uma string em tempo de execução, retorna zero caso tenha sucesso ou 1 caso falhe.

Muito útil quando você quer que seu programa leia e interprete comandos. Exemplo:

Dica: cuidado com as aspas, se a string a ser executada possui apas internamente você tem algumas opções:

1 – Usar aspas simples internamente, e duplas externamente ou o inverso, como no exemplo acima;

2 – Usar o mesmo tipo de aspas. Mas as internas devem ser antecedidas por barra oblíqua: \” ou \’ ex.:

 

Ou

3 – Usar duplos colchetes:

Como o argumento é uma única string podemos omitir o parênteses da função como fazemos desde o início com a função inclua. Ficando assim: executestring “seu_comando_aqui” .

---

executearquivo ( “caminho_do_arquivo.prisma” )

Semelhante ao comando executestring, mas ao invés de executar uma string, executa um programa prisma, que pode estar compilado ou não.

Muito útil quando seu programa tem vários subprogramas separados, sendo chamados pelo programa principal.

Esta função, executearquivo, em caso de haver erro no programa executado, simplesmente trava a execução do programa principal, fechando-o e imprimindo mensagem de erro na tela cmd (no Linux terminal).

Se o programa prisma a ser executado estiver na mesma pasta que o programa principal, não é necessário usar o caminho completo, caso contrário sim.

ex.:

Obs. Lembre-se que o nome do arquivo a ser executado deve ser escrito com a extensão.

Lembre-se de que no Windows as barras devem ser duplas, ex:

Ou use duplos colchetes:

Já no Línux não é necessário, pois as barras de endereço são assim: /

carregue ( string )

Semelhante a função executestring com a diferença de que esta carrega a string e retorna uma função dela para uma variável. Ex:

Se houver erros, simplesmente nenhum valor é retornado e o valor da função será nulo;

carreguearquivo ( “programa.prisma” )

Similar à função carregue, no entanto, esta carrega um arquivo fonte prisma ou programa compilado prisma em uma função que ao ser executada executa o programa carregado. Exemplo:

Esta função, ao contrário da executearquivo, dá a possibilidade de fazer um tratamento de erro:

convnumero( string )

Converte uma string para numero. Exemplo:

convstring ( numero )

Faz o contrário da função anterior, converte um número para string.

tente ( comando , ‘mensagem erro’);

Esta função verifica um valor e retorna um mensagem de erro caso esse valor seja falso ou nulo, ou o próprio valor caso ele seja válido.

Sua sintaxe é : x = tente ( valor , String_erro );

Esta função é ótima para testar abertura de arquivos. Veja seu uso:

Outro exemplo de uso com a função que abre arquivo em Prisma:

cod ( ‘Car’ )

Esta função converte um caractere para sua representação em bytes (número), há uma certa correspondência ao número de cada tecla do teclado.

Exemplo:

No exemplo, podemos observar que esta função converte a letra ‘A’ para o número 65.

E todos os caracteres de “tangerina” na variável a.

Obs.: O nome da função ‘cod’ faz referência a código (‘codifique’);

car ( cod )

Esta função converte de codigo para caractere, ou seja, o parâmetro é um número que será convertido para caractere.

Ex.:

compile( função )

Esta função converte uma função prisma em byte-code em tempo de execução retornando em forma de string codificada, é possível gravar em arquivo o resultado e chamá-lo posteriormente com os comandos inclua, carreguearquivo ou executearquivo.

ex.:

Não precisa necessariamente declarar a função antes, pode passar a função sem nomeá-la, isto é chamado de função anônima:

ex.2:

No próximo exemplo vou demonstrar como gravar em um arquivo e depois executar o arquivo:

ex.3:

Você pode usar em combinação com a função carreguearquivo e compilar um arquivo, veja:

---

pchame ( funcao, argumentos )

Chama (executa) uma função em modo protegido, isto é, se a função contiver erros a mesma não interfere na execução do programa principal. Ela retorna dois valores, o primeiro é um boolean (falso ou verdadeiro) e o segundo é a mensagem de erro caso tenha.

Caso haja um erro a função não é executada e o primeiro retorno é um falso seguido pela mensagem de erro se não tiver erro a função é executada, o primeiro retorno é verdadeiro e o segundo é o valor de retorno da função se houver, veja:

O primeiro parâmetro é a função a ser chamada e do segundo em diante são seus argumentos se tiver.

---

xpchame( funcao , funcao_erro , argumentos … )

Muito semelhante a de cima, mas com uma função de erro customizada, veja:

selecione( [‘#’ ou inteiro] , args … )

Essa função realiza uma seleção entre vários argumentos passados como parâmetro, ou se usar o ‘#’ retorna o número de argumentos.

sintaxe: selecione ( tipo , args ); //onde tipo pode ser ‘#’ ou um número inteiro.

ex.:

No exemplo acima retorna o número de argumentos variados, pois usamos o tipo ‘#’ como primeiro parâmetro para selecione;

Podemos usar um número inteiro e definir o retorno a partir dessa posição para frente dos argumentos passados:

Saída será: voce escolher a partir do argumento 3 56 78 90

Perceba que ao usar o 3 como primeiro parâmetro da função selecione, ela retorna os elementos a partir do terceiro, se usássemos o 4 seria a partir do quarto, se 5 a partir do quinto, se 2 a partir do segundo e assim por diante.

---

Cap. 2 – Funções da biblioteca string

Muito importante para o processamento de strings como procurar, recortar, substituir trecho de string por outra, etc.

string.cod / string.byte

A mesma função com nomes diferentes, use a forma que preferir.

Relembre a função cod, é exatamente a mesma função empacotada na biblioteca string. Ela converte um caractere para sua representação em bytes, veja:

Aceita dois parâmetros, o primeiro é o caractere ou string, o segundo é o número que indica na sequência qual caractere da string a ser convertido. Quando o segundo parâmetro é omitido, o primeiro caractere da string é o padrão.

---

string.car

exatamente a mesma função car vista na biblioteca base, use qual preferir

Converte o código numérico (ASCII) em caractere;

Aceita número variado de parâmetros separados por vírgula e retorna a string formada por eles, ou caractere se for único.

sintaxe: <span style="font-size: small;">s = string.car (n1, n2, n3, ...)</span>

---

Descrição:

Recebe 0 ou mais números e converte todos em caracteres correspondentes. É o oposto da função string.byte / string.cod

string.compile

Exatamente a mesma função que vimos na base: compile, use o modo que preferir.

Converte uma função em binário (byte-codes);

Sintaxe: <span style="font-size: small;">s = string.compile ( f )</span>

---

Descrição:

Converte uma função f em sua representação binária, que pode ser posteriormente processada com a função carregue( ).

Como a função compile foi bem tratada na biblioteca base, aqui só vou demonstrar um simples exemplo.

Ex.:

string.procure

Procura uma ‘string’ chave em uma string maior retornado sua posição:

sintaxe: string.procure( “string maior” , “chave” , número_inicio );

string maior é a string onde queremos procurar a string chave;

chave é a string a ser encontrada na maior;

número_inicio é a posição inicial para começar a procurar na string maior, se omitido, seu valor padrão é 1;

Ex.:

Há dois retornos, o primeiro é a posição inicial da string localizada, o segundo é a posição final, portanto precisamos usar duas variáveis para receber os valores.

Como dito antes o terceiro parâmetro, índice de posição inicial de busca, é opcional, e por padrão é 1, isto é a busca inicia pelo primeiro caractere da string.

Mas, as vezes você pode querer procurar por mais resultados da mesma chave de busca, e para isso o terceiro parâmetro é indispensável. A estratégia é guardar a posição do primeiro resultado de busca e por meio de um laço de repetição reiniciar a busca do ponto posterior ao último resultado, veja:

É possível usar patterns de busca ( caracteres especiais de busca).

Localizando uma string entre aspas, parenteses e chaves:

string.formate

Esta função serve para formatar strings por meio de caracteres de formatação, muito semelhante ao sprintf do C.

Sintaxe: retorno = string.formate( “String_formatacao” , args , … );

Exemplo básico:

Perceba que a saída é a primeira string mas no lugar do %s é posto o segundo argumento “Mundo”.

O %s é um exemplo de caractere de formatação para strings.

Número variado de argumentos

Note que poderá ser muito mais do que dois argumentos de formatação.

Obs.: para cada argumento de formatação deve haver um caractere de formatação respectivo(na mesma sequência).

Outros caracteres de formatação e exemplos:

• Prisma

  %c, %d, %E, %e, %f, %g, %G, %i, %o, %u, %X, e %x são usados para números. %q e %s para string.

  1 2 3

  %c, %d, %E, %e, %f, %g, %G, %i, %o, %u, %X, e %x são usados para números.   %q e %s para string.

  
   

Veja os exemplos de uso a seguir:

Prisma

s = string.format("%s %q", "Ola", "Programador Prisma!") // string normal e string com aspas imprima(s); //-> Ola "Programador Prisma!" s = string.formate("%c%c%c", 79,108,97) // caracteres imprima(s); //-> Ola s = string.formate("%e, %E", mat.pi,mat.pi) // exponenciação(elevado) imprima(s); //-> 3.141593e+000, 3.141593E+000 s = string.formate("%f, %g", mat.pi,mat.pi) // float(real) e compacto float imprima(s); //-> 3.141593, 3.14159 s = string.formate("%d, %i, %u", -100,-100,-100) // signed, signed, unsigned (todos inteiros) imprima(s); //-> -100, -100, 4294967196 s = string.formate("%o, %x, %X", -100,-100,-100) // números: octal, hexadecimal, hexadecimal imprima(s); //-> 37777777634, ffffff9c, FFFFFF9C s = string.formate("%03d, %02d , %07d" , 1 , 1 , 10 ); imprima(s); // --> 001, 01 , 0000010

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

s = string.format("%s %q", "Ola", "Programador Prisma!")   // string normal e string com aspas imprima(s); //-> Ola "Programador Prisma!"   s = string.formate("%c%c%c", 79,108,97) // caracteres imprima(s); //-> Ola   s = string.formate("%e, %E", mat.pi,mat.pi) // exponenciação(elevado) imprima(s); //-> 3.141593e+000, 3.141593E+000   s = string.formate("%f, %g", mat.pi,mat.pi)       // float(real) e compacto float imprima(s); //-> 3.141593, 3.14159   s = string.formate("%d, %i, %u", -100,-100,-100)     // signed, signed, unsigned (todos inteiros) imprima(s); //-> -100, -100, 4294967196   s = string.formate("%o, %x, %X", -100,-100,-100)     // números: octal, hexadecimal, hexadecimal imprima(s); //-> 37777777634, ffffff9c, FFFFFF9C   s = string.formate("%03d, %02d , %07d" , 1 , 1 , 10 ); imprima(s); // --> 001, 01 , 0000010

string.troque

Sintaxe: retorno1 , retorno2 = string.troque( “stringOriginal” , “string_pesquisada” , “troca” [ , numero_trocas])

Um recurso muito útil quando você quer trocar uma string por outra dentro de uma maior. Um quarto parâmetro opcional limita a quantidade de substituições. Veja que retorno 1 é a string original já trocada, e retorno2 é o numero de trocas feitas.

Ex.:

Observe que a função procura a string ‘Mundo’ dentro da primeira string, caso a localize, a substituição é feita por “Prisma”.

Outros exemplos:

Podemos usar caracteres especias para troca:

Prisma

s , n = string.troque("banana", "(an)", "%1-") // captura toda ocorrência an e substitui por an- imprima(s,n); // ban-an-a 2 s , n = string.troque("banana", "a(n)", "a(%1)") // parenteses em torno dos 'n' depois de 'a' imprima(s , n ) ; // ba(n)a(n)a 2 s , n = string.troque("banana", "(a)(n)", "%2%1") // em toda ocorrência 'an' é trocado por 'na' imrpima( s , n ); // bnanaa 2

1 2 3 4 5 6 7 8 9 10 11

s , n = string.troque("banana", "(an)", "%1-")   // captura toda ocorrência an e substitui por an- imprima(s,n); // ban-an-a        2   s , n = string.troque("banana", "a(n)", "a(%1)")   // parenteses em torno dos 'n' depois de 'a' imprima(s , n ) ; // ba(n)a(n)a      2   s , n = string.troque("banana", "(a)(n)", "%2%1") // em toda ocorrência 'an' é trocado por 'na' imrpima( s , n ); //   bnanaa       2

Você pode estar um pouco confuso sobre os ‘patterns’ (caracteres especiais para troca),

lembre-se de que o segundo argumento é para pesquisa e o terceiro para troca:

“(an)” = onde encontrar ‘an’ na string original ocorrerá a troca;

‘%1-‘ = %1 simboliza o argumento de pesquisa, o primeiro entre parênteses seguido pelo – ; logo a troca será an-

‘a(n)’ = todo ‘an’ para pesquisa sendo o ‘n’ capturado para usar como %1 na troca;

‘a(%1)’ = a troca será por a + ‘n’ simbolizado por %1

‘(a)(n)’ = an para pesquisa, na troca o a será = %1 e o n = %2

Trocando toda palavra válida por ela mesma entre sinais: (ex.: ola por <ola> ou “ola”)

string.capte

sintaxe: iterador = string.capte( string , ‘chave’ )

Esta função retorna um iterador de busca por chave. O iterador procurará através da string passada buscas por resultados da chave passada. Observe que é passado um iterador que pode ser usado com a função ‘para’, ex. :

Prisma

para palavra em string.capte( 'ola mundo em <prisma>; 2015 ', "%a+") inicio imprima( palavra ) fim /**saída: ola mundo em prisma **

1 2 3 4 5 6 7 8 9

para palavra em string.capte( 'ola mundo em <prisma>; 2015 ', "%a+") inicio     imprima( palavra ) fim /**saída: ola mundo em prisma **

o pattern (a chave) %a+ representa qualquer sequência de letra válida exceto números e sinais;

Tente modificar o programa acima substituindo “%a+” por “%d+” ou “%w+” e veja os resultados.

string.tamanho

Retorna o tamanho de uma string, sintaxe: retorno(número) = string.tamanho( ‘string’).

Ex.:

string.maiuscula

Retorna uma string que está em minúscula no formato maiúscula.

Sintaxe: retorno(STRING) = string.maiuscula(‘string’)

Ex.:

Obs.: caso já tenha alguma letra em maiúscula, nada é feito.

string.minuscula

Retorna uma string que está em maiúscula para minúscula.

Ex.:

Obs.: caso já tenha alguma letra em minúscula, nada é feito.

string.nconcat

Retorna uma string concatenada n vezes. Sintaxe: retorno = string.nconcat( “string” , numero_concat ).

Ex.:

string.inverta

Retorna uma string com ordem das letras invertidas. Sintaxe: retorno = string.inverta(“string”);

Ex.:

string.sub

(ou se preferir: string.corte)

Retorna uma substring de uma maior. Sintaxe: retorno = string.sub( “string_origial” , inicio , fim );

Onde inicio e fim são números, sendo 1 o início da string.

Números negativos representam do fim para o início, -1 é o último caractere.

Ex.:

Caso o segundo argumento seja omitido, então o valor padrão é o último caractere da string.

---

Cap. 3 funções do sistema operacional

Esta biblioteca permite a comunicação com algumas funções do sistema operacional, tais como data, horário, execute, etc.

Todos os métodos ficam guardados na tabela ‘sis’:

sis.relogio()

Retorna o tempo da CPU desde o início da execução de Prisma, em segundos.

Prisma

t = sis.relogio(); imprima(t) // saida: 11056.989

1 2	t = sis.relogio(); imprima(t) // saida: 11056.989

sis.data()

Retorna informações sobre data e horários. Sintaxe: sis.data(formatacao/opções);

ex.: imprimindo a data sem formatação, o resultado depende do sistema operacional:

exemplo formatado: ( %d = dia, %m = mês, %Y = ano)

Retornando uma tabela (‘*t’)

No exemplo logo acima, o argumento “*t” força o retorno de uma tabela.

Qualquer nome que escolher como retorno conterá os campos:

sis.diftempo()

Retorna a diferença de tempo entre t2 e t1

ex.:

sis.execute()

Execute um comando de terminal do sistema operacional, semelhante ao system() do C:

É possível chamar programas externos:

retorna verdadeiro exit 0 em caso de sucesso ou nulo exit: cod_erro em caso de falha

sis.saia()

Fecha a execução do programa e devolve um número de retorno para o sistema operacional:

sis.obtvarambiente()

Retorna o valor de uma variável de ambiente se ela estiver definida:

sis.remova()

Remove um arquivo, retorna verdadeiro caso tenha sucesso ou nulo msg_erro em caso de falha:

Cuidado, o arquivo é apagado definitivamente, não vai para a lixeira.

sis.renomeie()

Renomeia um arquivo, retorna verdadeiro ou falso + msg_erro;

sis.nometmp( );

Sintaxe: nome = sis.nometmp();

Retorna um nome aleatório para ser usado como arquivo temporário. O retorno depende do sistema:

Saída no Linux Ubuntu 14.04 = /tmp/prisma_yShId3

Windows Xp = \s1fo.

Você pode acrescentar extensões se quiser usando o operador de concatenar strings o “..”:

saída provável: linux = /tmp/prisma_yShId3.ext

no Windows = \s1fo..ext //no windows basta usar ‘ext’ ao invés de ‘.ext’ para não duplicar o ponto

OBS.: Note que esse comando apenas gera uma string não um arquivo, você teria que usar a função es.abra e passar o nome temporário gerado para ela.

sis.deflocal( local [, tipo ] )

Define o idioma (local) atual do programa.

sintaxe: sis.deflocal( local [, tipo ] )

Em que local é o idioma a ser aplicado, a string idioma depende do sistema operacional;

Se o primeiro e segundo parâmetros forem omitidos, então o retorno é o idioma já definido:

//saída no Windows XP = Portuguese_Brazil.1252

Se quiséssemos definir o idioma seria :

no Win :

Note que se o segundo parâmetro for evitado a definição do idioma é geral, mas podemos escolher o que mudar, por exemplo, se quiséssemos mudar somente os caracteres:

Eis abaixo as opções disponíveis.

OBS.: eu deixei em inglês mesmo para não haver confusão, visto que é fácil. No entanto, caso não se acostume copie o código abaixo em seu programa e use as variáveis personalizadas a seu gosto:

use assim:

sis.durma( milissegundos )

(Disponível em prisma a partir de prisma-1.0.91x – data 01-06-2015 )

Pausa a execução do programa por um tempo determinado em milissegundos

ex.:

Cap. 4 funções de entrada e saída padrão ‘es’

Essa biblioteca providencia funções para abrir e manipular arquivos, escrever, ler;

es.escreva(‘strings’ , … );

Esta função escreve na tela preta do terminal no Linux ou cmd no Windows. Semelhante ao comando imprima() com a diferença de que este não pula linhas. Ex:

Saída = Ola Mundo Em Prisma

Se tivéssemos usado o imprima, sairia assim:

Ola Mundo

Em Prisma

Obs.: es.escreva aceita vários argumentos, ex.:

es.leia ( );

é o mesmo que leia()

Esta função é usada para ler dados digitados pelo usuário, ou os dados de um arquivo;

O segundo uso veremos adiante, agora veja como ler do teclado:

LENDO E ESCREVENDO EM ARQUIVOS

---

Primeiro modo:

es.saida( )

Abre um arquivo de saida padrão para escrita, ex.:

//vá até a pasta disco C:\ e abra o arquivo criado ‘nomearquivo.txt’ em um editor de sua preferência e veja as linhas gravadas.

es.entrada( )

Esta função abre um arquivo de entrada padrão para leitura:

es.linhas( )

Essa função retorna um iterador para usar com o comando ‘para’, percorrendo todas as linhas de um arquivo:

ex.:

No exemplo acima, será impressa cada linha do arquivo. Se preferir pode armazenar em uma variável string ou tabela.:

es.feche( )

Fecha um arquivo padrão aberto:

---

LENDO E ESCREVENDO EM ARQUIVOS

Segundo modo:

es.abra( )

Sintaxe: objeto_arquivo = es.abra( ‘nomearquivo’ , ‘modo’) ;

em que nome arquivo é o caminho absoluto ou o relativo do arquivo, e modo pode ser:

‘leitura’ — para ler um arquivo

‘escrita’ — para escrever no arquivo, apagando o conteúdo original

‘leiturabin’ — leitura binária

‘escritabin’ — escrita binária, apaga o conteúdo original

‘adicao’ — escreve no final do arquivo, não apaga o conteúdo original

ex.:

Escrevendo

Note que neste caso criamos uma variável que herda os métodos escreva e feche;

OBS.: não esqueça de usar os dois pontos para acessar os métodos do objeto aberto.

Lendo

‘

Adicionando

Semelhante ao modo ‘escrita’ com a diferença que esse adiciona no fim do arquivo a gravação, e não apaga o conteúdo original.

---

Cap. 5 funções da biblioteca mat – trigonometria e aritmética

Suas funções ficam na tabela ‘mat’

Muito importante para realizar operações trigonométricas e aritméticas, como obter o arco tangente, o co-seno, exponenciação, absoluto, módulo(resto), raiz quadrada etc.

Vamos começar então!

mat.absoluto( n );

Retorna o valor absoluto de n. Veja:

Não quero aprofundar em matemática, portanto somente farei a descrição da sintaxe e retorno das funções, ok!

mat.arcocosseno( n )

Retorna o arco cosseno de n (em radianos);

ex.:

mat.arcoseno( n )

Retorna o arco seno de n (em radianos);

Ex.:

mat.arcotangente( n )

Retorna o arco tangente de n (em radianos);

mat.arcotangente2( n1 , n2 )

Retorna o arco tangente de n1/n2 (em radianos), no entanto, utiliza o sinal dos dois parâmetros para achar o quadrante do resultado. (Também trata corretamente o caso de x ser zero.)

mat.arredonde ( n )

Retorna o n caso seja inteiro, ou arredonda para mais caso seja fracionário. Veja:

mat.cosseno ( n )

Retorna o cosseno de n ( n deve estar em radianos).

mat.cossenoh ( n )

Retorna o cosseno hiperbólico de n.

mat.emGrau ( r )

Converte r que está em radianos para graus.

mat.exp ( n )

Retorna o número de euler elevado a n (e^n). Euler e um número irracional, aproximadamente é 2,718281828459045, ou, às vezes apenas 2,718281828459).
O número de Euler é comum ser chamado de e.

mat.corte ( n )

Arredonta por baixo, se 2.5, por exemplo, será 2, ou quando o número for inteiro retorna o próprio número.

mat.cmodulo ( n1 , n2 )

Retorna o resto da divisão de n1 por n2 que arredonda o quociente em direção a zero.

mat.frexp ( n )

Retorna m e e tais que n = m2^e, e é um inteiro e o valor absoluto de m está no intervalo [0.5, 1) (ou zero quando x é zero).

mat.infinito

Na verdade não é uma função é um dado que representa o valor de HUGE_VAL, um valor maior ou igual a qualquer outro valor numérico.

mat.ldexp( m , e )

Retorna m2^e (m vezes 2 evevado a e. e deve ser um inteiro).

O inverso de mat.frexp(n).

mat.log( n )

Retorna o logaritmo natural de n. Isto é, retorna a potência em que o número de Euler (2,718281828459045) precisa estar elevado para que resulte no seu logaritmo.

mat.log10( n )

Retorna o logaritmo base-10 de n. Ou seja, retorna o valor que dez precisa ser elevado para dar n.

mat.maximo( … )

Retorna o valor máximo entre os seus argumentos.

mat.minimo( … )

Retorna o valor mínimo entre os seus argumentos.

mat.separe( n )

O retorno é duplo, considerando n um número fracionário (1.5 por exemplo), serão retornadas a parte integral de n (1) e a parte fracionária de n (0.5).

mat.pi

Não é função, representa o valor de pi:

mat.elevado( n1 , n2 )

Retorna n1^n2 (n1 elevado a n2 ). Esta operação é possível com o sinal de ^ assim como se pode somar n1+n2 direto em prisma, pode-se usar n1^n2 diretamente.

rad = mat.emRadianos( graus )

Converte de graus para radianos:

mat.randonico( inicial , final )

Retorna um inteiro pseudo-aleatório no intervalo inicial e final.

Se omitido os parâmetros inicial e final, o retorno é um aleatório entre 0 e 1;

Se passarmos apenas um argumento, o retorno será um aleatório entre 1 até o argumento passado.

mat.xrandonico( n )

Define um número gerador pseudo-randônico. Gerador igual produz sequências iguais:

Prisma

mat.xrandonico(1234) imprima( mat.randonico(), mat.randonico(), mat.randonico() ) // 0.12414929654836 0.0065004425183874 0.3894466994232 mat.xrandonico(1234) imprima( mat.randonico(), mat.randonico(), mat.randonico() // 0.12414929654836 0.0065004425183874 0.3894466994232

1 2 3 4 5 6

mat.xrandonico(1234) imprima(  mat.randonico(), mat.randonico(), mat.randonico()   ) // 0.12414929654836        0.0065004425183874      0.3894466994232 mat.xrandonico(1234) imprima( mat.randonico(), mat.randonico(), mat.randonico() // 0.12414929654836        0.0065004425183874      0.3894466994232

Um ótimo recurso para criar um gerador é a função sis.tempo():

mat.xrandonico( sis.tempo() )

1	mat.xrandonico( sis.tempo() )

mat.seno( n )

Retorna o seno de n ( n deve estar em radianos).

mat.senoh( n )

Retorna o seno hiperbólico de n.

mat.raizquad ( n )

Retorna a raiz quadrada de n.

A mesma operação pode ser feita com o ^(1/2)

Raiz cúbica:

Raiz quártica, e assim por diante:

mat.raiz ( n , z )

Retorna a raiz de índice ‘z’ de n:

mat.tangente ( n )

Retorna a tangente de n ( n deve estar em radianos).

mat.tangenteh ( n )

Retorna a tangente hiperbólica de n.

---

Cap. 6 Funções da biblioteca tabela

Tabela é um poderoso recurso de manipulação e descrição de dados em Prisma. Com ela é possível fazer uma simples matriz como em C, ou até mesmo algo mais complexo e de forma simples como um registro.

Tabelas em Prisma não precisam ser declaradas com tamanho fixo, são dinâmicas e flexíveis sempre aceitando mais um elemento. Ex:

A biblioteca tabela oferece facilidades para manipular esse tipo de dado. Seus métodos estão contidos no nome “tabela.”

tabela.concat( tabela [,sep [ , inicial [ , final ]]] )

Concatena ( une ) os elementos da tabela.

Omitindo os demais parâmetros:

Usando os demais parâmetros:

 

tabela.ordene( tabela );

Coloca os índices em ordem crescente:

A ordenação da tabela pode ser customizada por uma função como segundo parâmetro, esta função deve retornar um valor boolean ( verdadeiro ou falso ). O retorno padrão é a<b, veja:

Prisma

t = { 3,2,5,1,4 } tabela.ordene(t, funcao(a,b) retorne a < b fim) imprima( tabela.concat(t, ", ") ); // 1, 2, 3, 4, 5

1 2 3 4

t = { 3,2,5,1,4 } tabela.ordene(t, funcao(a,b) retorne a < b fim) imprima(  tabela.concat(t, ", ")  ); // 1, 2, 3, 4, 5

ou defina a>b para ordenar em decrescente:

Prisma

t = { 3,2,5,1,4 }; tabela.ordene(t, funcao(a,b) retorne a > b fim ); imprima( table.concat(t, ", ") ); // 5, 4, 3, 2, 1

1 2 3 4

t = { 3,2,5,1,4 }; tabela.ordene(t, funcao(a,b) retorne a > b fim ); imprima( table.concat(t, ", ")  ); // 5, 4, 3, 2, 1

tabela.insira (tabela , [pos,] valor );

Insere um valor em uma tabela. Se uma posição for dada, o valor é inserido no lugar do valor atual que sobe uma posição no índice:

t = { 1,3,"quatro" } tabela.insira(t, 2, "dois"); //insere "dois" na posicao antes do segundo elemento imprima( tabela.concat(t, ", ") ); //1, dois, 3, quatro

1 2 3 4 5

t = { 1,3,"quatro" } tabela.insira(t, 2, "dois"); //insere "dois" na posicao antes do segundo elemento imprima( tabela.concat(t, ", ") ); //1, dois, 3, quatro

Se a posição não for especificada, o novo valor é inserido no fim da tabela

t = { 1,"dois" , 3 , "quatro" }; tabela.insira(t, 5); imprima( table.concat(t, ", ") ); 1, dois, 3, quatro, 5

1 2 3 4

t = { 1,"dois" , 3 , "quatro" }; tabela.insira(t, 5); imprima(  table.concat(t, ", ")  ); 1, dois, 3, quatro, 5

Quando um novo valor é inserido em uma tabela, ela atualiza o tamanho e a sequência dos elementos:

t = { 1,"dois",3 }; //criando a tabela imprima( #t ); //imprimido o tamanho da tabela // 3 //percorrendo em imprimindo os indices: para indice , valor em ipares( t ) inicio imprima( indice , valor ); fim /** 1 1 2 dois 3 3 **// tabela.insira(t, 1, "novo_valor"); //novo_valor inserido no indice 1; imprima( tabela.concat(t, ", ") ); imprima( # t );//tamanho atual da tabela //4 para indice, valor em ipares( t ) inicio imprima( indice , valor ); fim /** 1 novo_valor 2 1 3 dois 4 3 **// //valores foram deslocados para um índice acima //para dar espaço ao novo_valor

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

t = { 1,"dois",3 }; //criando a tabela imprima( #t ); //imprimido o tamanho da tabela // 3 //percorrendo em imprimindo os indices: para indice , valor em ipares( t ) inicio    imprima( indice , valor ); fim /** 1       1 2       dois 3       3 **//   tabela.insira(t, 1, "novo_valor"); //novo_valor inserido no indice 1;   imprima( tabela.concat(t, ", ") );   imprima( # t  );//tamanho atual da tabela //4 para indice, valor em ipares( t ) inicio    imprima( indice , valor ); fim /** 1       novo_valor 2       1 3       dois 4       3   **// //valores foram deslocados para um índice acima //para dar espaço ao novo_valor

tabela.remova(tabela [, pos])

Remove um elemento da tabela na posição definida e retorna o elemento removido. Se a posição não for definida o padrão é o último elemento:

Prisma

t = { 1,"dois",3,"quatro" };//cria a tabela imprima( #t ); //tamanho da tabela // 4 para i , v em ipares( t ) inicio imprima( i , v ); fim /** 1 1 2 dois 3 3 4 quatro **// removido = tabela.remova(t,2); //remove o índice 2 e o retorna: // dois para i , v em ipares ( t ) inicio imprima( i , v ); fim /** 1 1 2 3 3 quatro **// imprima( #t ); //tamanho atualizado // 3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

t = { 1,"dois",3,"quatro" };//cria a tabela imprima( #t ); //tamanho da tabela // 4 para i , v em ipares( t ) inicio    imprima( i , v ); fim /** 1       1 2       dois 3       3 4       quatro **// removido = tabela.remova(t,2); //remove o índice 2 e o retorna: // dois   para i , v em ipares ( t )  inicio   imprima( i , v ); fim /** 1       1 2       3 3       quatro **// imprima( #t ); //tamanho atualizado // 3

tabela.maxn( tabela );

Retorna o número de elementos da tabela:

ou use #t

tabela.empacote( … );

Transforma o número variável de argumentos ‘…’ em tabela, passando o retorno a uma variável.

tabela.desempacote( tabela );

O inverso da função anterior, transforma uma tabela em argumentos variados

FIM

 

Bom, espero que tenha sido útil. Qualquer crítica ou dúvida poste nos comentários, ou no fórum.

Obrigado por baixar o manual e usar Prisma, atualizações em breve!

 

Fique ligado, acesse o site Prisma clicando aqui.