A Linguagem Mora
Jander Moreira
 
 
Esta linguagem utiliza a notação postfix. ">" é a atribuição e "nig" é
"não igual" e "sup" é "superior" (ou "maior que").
Idéia geral: dizer o que fazer através de regras e depois 'mandar
ver' (no caso, a repetição...).
Exemplos (veja antes de ver a especificação):
 
EXEMPLO 1:
// ### Codificação: SomaSimples
// Faz a soma S = 1/2 - 2/5 + 3/8 - 4/11 + 5/14 - ...
// para N termos
 // iniciações
 2 > Denom
 1 > Sinal
 0 > Soma
 
 // regras para usar na repetição
 -Sinal > Sinal quando Sinal
 I Den' / Sinal' * >+ Soma quando I
 3 >+ Den quando Den
 
 // repetição
 Repetir N vezes em I // N não tem valor,
 // i.e., faz leitura
 
 // Saída
 Soma
// ### Fim da codificação
 
Corresponde ao algoritmo:
 
Agoritmo SomaSimples
{ exemplo de soma com termos alternantes }
 Declare Soma: real
 I, N, Sinal, Denom: inteiro
Início
 Leia(N)
 Soma <- 0
 Sinal <- 1
 Denom <- 2
 Para I <- 1 até N
 Soma <- Soma + Sinal * I/Denom
 Sinal <- -Sinal
 Den <- Den + 5
 Fim-para
 Escreva(Soma)
Fim
 
 
 
EXEMPLO 2:
// ### Codificação: SomaPositivosENãoPositivos
// Soma número de positivos e não-positivos em
// vários valores lidos
 // iniciações
  0 > SPos > SNPos
 
 // regras
 1 >+ NPos ou
 1 >+ NNaoPos se N 0 sup quando N
 
 // repetição
 Repetir N' se 0 N^ nig
 
 // Saídas
 SPos
 SNaoPos
// ### Fim da codificação
 
Corresponde ao algoritmo:
 
Agoritmo SomaPositivosENãoPositivos
{ exemplo de soma }
 Declare SPos, SNaoPos: real
 N: inteiro
Início
 SPos <- 0
 SNaoPos <- 0
 Repita
 Leia(N)
 Se N > 0
 Então NPos <- NPos + 1
 Senão NNaoPos <- NNaoPos + 1
 Fim-se
 Até N = 0
 Escreva(NPos, NNaoPos)
Fim
 
=========================================================
 
 
Nome: Moro
Amoreira, em italiano: "amoreira" para moreira; italiano
por parte de minha mãe... 
 
 
Idéia: Funcionamento através de regras que criam dependências dos
dados (inspirada em fluxo de dados). A notação geral é postfix.
 
Comandos:
- Atribuição
 2 B * > A // A = B * 2
 1 >+ A // A = A + 1
 0 > B > C // B = 0 ; C = 0
 
- Saída
 Referência isolada a variável que tem algum valor
 
 A // escreva(A)
 B // escreva(B)
 
- Entrada
 Qualquer referência (rvalue*) a uma variável ainda sem valor
 [*Nesta notação, rvalues ficam à esquerda...  ]
 
 // A tem valor 5; B ainda não teve atribuição
 A B * > C // Faz a leitura de B da entrada padrão
 
- Remoção de valor
 Referência a variável com o modificador ^.
 Pode ser usado em qquer lugar (rvalue).
 
 A B^ * > C // usa valor de B e o remove da variável
 D^  // remove valor de B e não escreve
 
- Remoção de regra
 Referência à variável com modificador ~
 
 A~ > B // B = A e remove regras de A
 N~ // remove regras de N e não escreve
 
- Criação de regra de dependência
 Cria regra associada a uma variável. Pode haver
 várias regras para uma mesma variável. A ordem é
 a da definição.
 Formato: COMANDO quando VARIÁVEL
 
 -1 >* Sinal quando Sinal // Sinal = -Sinal
 // ativa quando usa Sinal'
 
- Ativação de regra
 Uso da variável com o modificador '
 
 // Usa valor de Sinal e ativa regra (ex. acima)
 I Sinal' * > S // S = I * Sinal
 
- Condicional
 Define comandos executados condicionalmente e
 cria regra dependente de variável. Formato:
 COMANDO-V ou
 COMANDO-F se CONDIÇÃO quando VARIÁVEL
 
 // Soma positivos e não positivos
 1 >+ SPos ou
 1 >+ SNaoPos se N 0 sup quando N // "sup" é ">"
 
- Repetição determinística
 Repete de k vezes (de 1 até k). Formato:
 Repetir EXPRESSÃO vezes em VARIÁVEL
 
 // Para I = 1 até N
 Repetir N vezes em I
 
- Repetição não determinística
 Repetição dependente de condição. Formatos:
 1. Repetir se CONDIÇÃO em VARIÁVEL
 2. Repetir em VARIÁVEL se CONDIÇÃO
 A forma 1 é o enquanto; a 2 é "do-while".
 
 // Repita até que N = 0
 Repetir em N' se 0 N nig // "nig" é "!="
 
- Agrupamento de comandos
 Vários comandos são colocados como um só com uso
 do concatenador "e".
 
 // 2 comandos em um só condicional (sem "senão")
 I' e
 J' se A B ig
- Sub-rotinas
 Só existem funções, que podem voltar um "void".
 Formato:
 
 [ LISTA-PARÂMETROS
 
 REGRAS E COMANDOS ] > NOME-FUNÇÃO
 
 // função fatorial
 [ N // parâmetro
 1 > Fat
 I >* Fat quando I
 Repetir N vezes em I
 Fat > Fatorial // valor de retorno
 ] > Fatorial
 
 // procedimento
 [ I J
 ... // não tem "valor > Proc"
 ... // em lugar nenhum...
 ] > Proc
 
- Arranjos e registros
 Seguem padrões comuns (e.g., Pascal ou C).
 
 // arranjo
 A dimensionado em 10 // A(1) até A(10)
 -5 > A(I)
 
 // registro
 Registro
 X
 Y
 Nomeado Reg