IPETEQS

O que é IPETEQS em JavaScript?

Visando a possibilidade de executar PETEQS em qualquer lugar, ipeteqs foi portado para Javascript. Assim como o interpretador original, ele traduz a linguagem PETEQS para uma linguagem real e a executa, sendo escrito em Javascript ambos o tradutor e o código traduzido.

Sendo importado em uma página, recebe um string de código PETEQS e retorna a execução deste código.

A linguagem PETEQS

PETEQS é uma pseudolinguagem utilizada no aprendizado de lógica de programação em algumas faculdades, especificamente na UFF.

A linguagem PETEQS possui todas as operações básicas, incluindo:

• Atribuição: `a <- 1`
• Soma: `a <- 2 + 2`
• Subtração: `a <- 2 - 1`
• Multiplicação: `a <- a * 20`
• Módulo: `a <- a mod 5`

Além disso, ela possui divisão, onde um número dividido sempre terá seu resultado como um inteiro, a menos que seja explicitamente declarado com um ponto decimal.

Exemplo de divisão:

• `a <- 20 / 2` (a será 10)
• `a <- 20 / 3` (a será 6)
• `a <- 20.0 / 3` (a será 6.666...)

PETEQS também inclui desvios condicionais, como `SE ... ENTÃO ... FIM SE`, e estruturas de repetição, como `PARA ... FAÇA ... FIM PARA` e `ENQUANTO ... FAÇA ... FIM ENQUANTO`.

Além disso, possui procedimentos e funções para modularização do código.

As funções de entrada e saída básicas em PETEQS são `leia`, `imprima` e `imprimaln`.

PETEQS também suporta vetores, variáveis indexadas.

Desvios Condicionais em PETEQS

PETEQS possui desvios condicionais, que atuam nos operadores lógicos `>`, `>=`, `<`, `<=`, `<>` e `=`.

Exemplo de desvio condicional:

            
                SE a > 0 ENTÃO
                  //Código aqui
                FIM SE
    
                SE b < 100 ENTÃO
                  //Faça algo aqui
                SENÃO
                  //Faça outra coisa aqui
                FIM SE  
    
                SE C = 2 ENTÃO
                  imprimaln 'C é 2'
                SENÃO SE C <> 3
                  imprimaln 'C não é 3'
                SENÃO
                  imprima 'C é qualquer outro número'
                FIM SE
            
        

Estruturas de Repetição em PETEQS

PETEQS inclui duas estruturas de repetição: os laços `PARA` e os laços `ENQUANTO`.

Exemplo de laço `PARA`:

            
                //Contador de ano novo
                PARA i <- 10 ATÉ 1 FAÇA
                  imprima i
                FIM PARA
    
                //De modo geral
                PARA Início ATÉ Final FAÇA
                  //Ação
                FIM PARA
            
        

Exemplo de laço `ENQUANTO`:

            
                saldo <- 100
                ENQUANTO saldo > 0 FAÇA
                  saldo <- saldo - 5
                FIM ENQUANTO
    
                //De modo geral
                ENQUANTO Condição FAÇA
                  //Ação
                FIM ENQUANTO
            
        

Procedimentos e Funções em PETEQS

PETEQS possui procedimentos e funções para modularização do código.

Exemplo de função em PETEQS:

            
                FUNÇÃO É_PAR(entrada: num, saída: é_impar)
                INÍCIO
                   SE num mod 2 <> 0 ENTÃO 
                     resultado <- Falso
                   SENÃO
                     resultado <- Verdadeiro
                   FIM SE
                FIM
    
                PROCEDIMENTO ImprimePares()
                INÍCIO
                  PARA i <- 0 ATÉ 100 FAÇA
                     SE É_PAR(i) ENTÃO
                       imprimaln i
                     FIM SE
                  FIM PARA
                FIM
    
                ImprimePares()                  //Imprime todos os números pares
            
        

Entrada e Saída em PETEQS

PETEQS possui funções básicas de entrada e saída, incluindo `leia`, `imprima` e `imprimaln`.

Exemplo de entrada e saída em PETEQS:

            
                // Em vez de fazer assim:
                leia gato_1
                leia gato_2
                leia gato_3
    
                imprima gato_1
                imprima gato_2
                imprima gato_3
    
                // Com as funções de entrada PETEQS, com o uso de vetores podemos:
                PARA i <- 1 ATÉ 3 FAÇA
                  leia gato[i]
                  imprima gato[i]
                FIM PARA