univali-lite-backup / portugol-nucleo Goto Github PK

Quando é realizado uma divisão por zero com o tipo real, não está sendo gerado um erro de execução. O que acontece é que o resultado da operação é "infinity".
substituir esse comportamento por uma pausa na execução e aviso de erro, similar ao que acontece na divisão por zero com números inteiros.

O analisador semântico permite utilizar um nome de variável como se fosse uma função.
O erro não é detectado durante a análise semântica, mas dá erro durante a execução do algoritmo.
Segue abaixo o algoritmo utilizado para identificar o erro:

programa
{
    funcao inicio(cadeia parametros[])
    {
        inteiro soma = 24

        soma(2, 3)
    }
}

O erro gerado durante a execução é: "java.lang.ClassCastException: br.univali.portugol.nucleo.simbolos.Variavel cannot be cast to br.univali.portugol.nucleo.simbolos.Funcao".

segue código que o Raabe identificou o problema.

funcao desenha(caracter x[]){

   para(inteiro i = 0; i < 5; i++)
    {
        escreva (x[i], branco(3) )
    }
}

funcao branco (inteiro n){
    para(inteiro i = 0; i < n; i++){
      escreva (" ")
    }
}

funcao inteiro fat (inteiro n){
    inteiro r
    se (n <= 1){ 
        retorne (1)
    }
    senao{
      r = n * fat (n-1)
      retorne (r)
    }
}

funcao inicio(){
    caracter x[5] = {'a','n','d','r','e'}
    //desenha (x)
escreva (fat(4))


}

}


Durante a depuração normal, alguma instruções estão sendo puladas, pois não estão sendo elegidas para depuração pelo detector de nós de parada.

Na depuração detalhada eles são detectados corretamente.

No código abaixo, o 2º escreva dentro do 'se' é pulado sempre.
O 1º escreva após o 'se' também e pulado.

programa
{
    funcao inicio() 
    {
        //escreva(fatorial(5))
        
        inteiro a       
        a = 0

        para (a = 0; a <= 10; a++)
        {
            escreva("\n", a)
        
            se (a == 5)
            {
                pare
            }

            escreva("Não passa aqui")
        }

        escreva("Pula esse")
        escreva("Passa esse")
    }

    funcao inteiro fatorial(inteiro n) 
    {
        se ( n <= 1)
            retorne 1
        senao 
        {
            retorne n * fatorial(n-1)   
        }
    }
    
}

Finalizar a parte de bibliotecas.

Ao chamar uma função, o parâmetro vem com o valor errado se houver um símbolo local com o mesmo nome do parâmetro

programa
{
    funcao inicio()
    {
        inteiro a = 50
        
        teste(a)
    }

    funcao teste(inteiro a)
    {
                //Deveria imprimir 50, mas está imprimindo 0
        escreva(a)
    }
}

Decidir se esse tipo de construção será possível na linguagem

ex:
programa
{
funcao inicio(cadeia parametros[])
{
inteiro a[] = {1,2,3,4}
a = 2
teste(a)
}

funcao vazio teste(inteiro variavel[])
{
    escreva(variavel[1])    
}

}

o programa executa mas não imprime

funcao inicio()
{

    escreva(media(8,7,7))
}

//Funçao 
funcao inteiro media(inteiro m1, inteiro m2, inteiro m3)
{
    retorne (m1 + m2 + m3) / 3.0    
}

// Este exemplo demostra um fatorial gerado recursivamente.
// O exemplo pede ao usuário um valor e ao fim é exibido o fatorial deste número.
programa
{

// Função recursiva que calcula o fatorial do número passado
funcao inteiro fatorial(inteiro numero){
se(numero == 1){
retorne 1
}
retorne numero*fatorial(numero-1)
}
funcao inicio()
{
inteiro valor
escreva("Digite um número inteiro para saber o fatorial dele: ")
leia(valor)
escreva("O fatorial do número digitado é: ",fatorial(valor)) // chama a função recursiva e exibe o valor final
}
}

<< Bitwise left shift

Bitwise right shift
& Bitwise AND
^ Bitwise XOR
| Bitwise OR
<<= Atribuição com bitwise left shift
= Atribuição com bitwise right shift
&= Atribuição com bitwise AND
^= Atribuição com bitwise XOR
|= Atribuição com bitwise OR

valores hexa passam a ser considerados como inteiros.
ex:
inteiro teste = 0xAf01

No depurador, implementar um método/funcionalidade para permitir que o usuário pule todos os passos da depuração a partir do ponto de parada atual, e assim finalize a execução do algoritmo.

Supondo que o algoritmo abaixo estivesse sendo depurado, e que o depurador estivesse na segunda instrução, ao acionar este método, o algoritmo terminaria a execução, imprimindo todos os dados na saída.

programa
{
    funcao inicio()
    {
        escreva("\n", 1)
        escreva("\n", 2)
        escreva("\n", 3)
        escreva("\n", 4)
        escreva("\n", 5)
    }
}

De forma semelhante, pode haver um método para retomar a depuração passo a passo quando o depurador estiver no estado "Continuar".

Por exemplo, ao depurar o programa abaixo, suponha que o usuário informou o valor 1.000.000 para variável e depois chamou o método continuar no depurador.

Ao fazer isso, o programa passaria a executar as instruções dentro do laço sem interagir novamente com o usuário, até que a condição do laço fosse satisfeita.

No entanto, ao chamar o método retomar do depurador, o depurador pararia na instrução que está sendo executada atualmente permitindo que o usuário continuasse depurando passo a passo a partir desta instrução.

programa
{
    funcao inicio()
    {
        inteiro a = 0, b = 0
 
        leia(b)

        enquanto (a <= b)
        {
             escreva(a, "\n")
             a = a + 1
        }
    }
}

não reconhece erro ao realizar chamada a função "esreva"

Ao tentar declarar uma constante com valor negativo o Núcleo gera um erro semântico.

programa
{
    funcao inicio()
    {
        const inteiro a = -9
    }
}

O núcleo deve lançar um aviso de que uma varivel do escopo da funcao possui o mesmo nome da varivel de escopo global.
ex:

programa{
  inteiro a
  funcao inicio() {
    inteiro a
  }
}

programa
{
funcao inicio()
{
inteiro a[2] = {1, 2}

teste(a)
}

funcao teste(inteiro a[])
{
escreva(a[0])
}
}

Por exemplo:

caso uma variável tenho o nome preço

Ao executar a analise semântica no código a seguir é mostrado para o usuário o stacktrace,

programa
{
   funcao inicio()  {
      inteiro a.
      escreva("teste")
   }
}

Relacionado com a Issue #18

O semântico não deveria permitir a execução do código a seguir:

programa
{
    funcao inicio()
    {
        inteiro a[][] = {{1,2,3},{1,2,3}}       
        teste(a)

        inteiro b[] = {1,2,3}
        teste2(b)
    }

    funcao vazio teste(inteiro v[])
    {
        escreva("\n",v[0])
    }

    funcao vazio teste2(inteiro v[][])
    {
        escreva("\n",v[0][0])
    }
}

leia
escreva
limpa,
sorteia,
potencia,
raiz,
aguarda

A análise semântica não está sendo realizada corretamente nos retornos de função.
Ao executar o algoritmo abaixo é gerada uma exceção no Java.
O semântico deveria ter acusado a variável "b" como não declarada.

programa
{
    funcao inicio(cadeia parametros[])
    {
        inteiro a = 23

        escreva(incrementa(a))
    }

    funcao inteiro incrementa(inteiro a)
    {
        a = a + 1       

        retorne b
    }
}

Stacktrace:

Erro: java.lang.NullPointerException
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorVariavel(Interpretador.java:1484)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorReferencia(Interpretador.java:1288)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorExpressao(Interpretador.java:584)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretarBloco(Interpretador.java:378)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretarListaBlocos(Interpretador.java:347)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorFuncao(Interpretador.java:1532)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorReferencia(Interpretador.java:1335)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorExpressao(Interpretador.java:584)
at br.univali.portugol.nucleo.execucao.Interpretador.escreva(Interpretador.java:1392)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorReferencia(Interpretador.java:1305)
at br.univali.portugol.nucleo.execucao.Interpretador.obterValorExpressao(Interpretador.java:584)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretarBloco(Interpretador.java:404)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretarListaBlocos(Interpretador.java:347)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretarFuncaoPrincipal(Interpretador.java:316)
at br.univali.portugol.nucleo.execucao.Interpretador.interpretar(Interpretador.java:104)
at br.univali.portugol.nucleo.Programa$1.run(Programa.java:109)
at java.lang.Thread.run(Thread.java:662)

depois de usar caracteres especiais como: ç á ê , ; em locais indevidos na segunda execução já com os caracteres removidos o Portugol-Nucleo para de responder.

Bug relacionado com a Issue #21

Ao realizar a depuração detalhada no laço para, é feito o highlight na condição antes de realizar o highlight na declaração, essa primeira parada não deveria acontecer.

O depurador não está fazendo hightlight quando encontra um nó pare no código fonte.

funcao inicio()
{
inteiro vet1[5]
//inteiro vet2[5] = {1,2,3,4,5} <-- eliminar essa construção
inteiro vet3[] = {9,8,7,6,5}

    //permitir o seguinte caso:
    inteiro tamanho
    leia(tamanho)
    real vetor[tamanho]

}

programa
{
funcao inicio()
{
teste(1,'a')
}
funcao inteiro teste(inteiro a, caracter teste)
{
teste(1,'a')
}
}

Codigo de teste:
programa
{
funcao inicio()
{
inteiro b = 0
para(b=0;b<10;){
escreva(b)
b++
}
}
}

Ao declarar diferentes funções ("a" e "b") com os mesmos nomes de parâmetros, o semântico acusa que os parâmetros da função "b" já foram declarados, pois a função "a" possui os mesmo nomes de parâmetros.

Ex.:

programa
{
    funcao inicio()
    {   
        escreva(multiplica(5, 10))
        
        escreva(divide(2, 1))
    }

    funcao real multiplica(real k, real f)
    {
        retorne k * f
    }

    funcao real divide(inteiro k, inteiro f)
    {
        
    }
}

programa
{
inclua biblioteca Matematica --> m
funcao inicio()
{
m.PI = 20.23
escreva(m.PI)

}
}

Ao consertar a Issue #30 pouco foi feito para deixar as mensagens agradáveis.

Quando é mandada a variável, aparece um erro dizendo que a variável que no caso é um vetor está sendo usado como uma variável simples.

Algoritmo que gera o erro:

programa
{
funcao inicio(cadeia parametros[])
{
inteiro a[] = {1,2,3,4}
teste(a)
}

funcao vazio teste(inteiro variavel[])
{
escreva(variavel[1])
}
}

Criar um mecanismo que facilite a personalização e tradução das mensagens de erro.

O semântico deixa passar um valor constante/expressão por referência em uma chamada de função. O interpretador dá pau:

programa
{
    funcao inicio()
    {
        teste(50)
    }

    funcao teste(inteiro &a)
    {
        a = 20
    }
}

falta vericar as funcoes que o andre escreveu em uma folha que esta com o noschang.

Retirar a inicialização das variáveis com zero, ou então impedir o uso delas quando não foram inicializadas.
Os alunos estão começando a usar o C e estão sempre esquecendo de inicializar as variáveis

programa
{
inclua biblioteca Teste --> util
funcao inicio()
{
inteiro a[2][2] = {{1, 2}, {3, 4}}

util.teste(a)
}
}

package br.univali.portugol.nucleo.bibliotecas;

import br.univali.portugol.nucleo.bibliotecas.base.Biblioteca;
import br.univali.portugol.nucleo.bibliotecas.base.ReferenciaMatriz;
import br.univali.portugol.nucleo.bibliotecas.base.TipoBiblioteca;
import br.univali.portugol.nucleo.bibliotecas.base.anotacoes.Autor;
import br.univali.portugol.nucleo.bibliotecas.base.anotacoes.DocumentacaoBiblioteca;
import br.univali.portugol.nucleo.bibliotecas.base.anotacoes.DocumentacaoFuncao;
import br.univali.portugol.nucleo.bibliotecas.base.anotacoes.DocumentacaoParametro;
import br.univali.portugol.nucleo.bibliotecas.base.anotacoes.PropriedadesBiblioteca;
import br.univali.portugol.nucleo.mensagens.ErroExecucao;
import java.util.Random;

@PropriedadesBiblioteca(tipo = TipoBiblioteca.COMPARTILHADA)
@DocumentacaoBiblioteca
(
descricao = "Esta biblioteca contém diversas funções utilitárias",
versao = "1.0"
)
public final class Teste extends Biblioteca
{
private Random random = new Random(System.currentTimeMillis());

@DocumentacaoFuncao
(
    descricao = "Descobre o número de elementos existentes em um vetor",
    parametros = 
    {
        @DocumentacaoParametro(nome = "vetor", descricao = "o vetor em questão")
    },
    retorno = "O número de elementos existentes no vetor",
    autores = 
    {
        @Autor(nome = "Luiz Fernando Noschang", email = "[email protected]")
    }
)
public void teste(ReferenciaMatriz<Integer> matriz) throws ErroExecucao
{
    System.out.println(matriz.obterValor(0, 0) + 1);
}

}

java.lang.ClassCastException: br.univali.portugol.nucleo.simbolos.Vetor cannot be cast to br.univali.portugol.nucleo.simbolos.Variavel

Algumas vezes o analisador semântico não esta entregando mensagem de variável não declarada.

construções como: 2,5 - 3,78 apresentam a mensagem padrão do erro MissignTokenException. Melhorar a mensagem para algo parecido com: "valores reais devem utilizar o caracter . como separador decimal".

Investigar travamento. Uma das suspeitas é o mecanismo threads utilizado para chamar as funções do núcleo dentro do Portugol Studio.

Um travamento constante possuí a seguinte característica:

1 - O código possui erros,
2 - Corrige-se os erros e rapidamente clique em play
3 - repita os passos com rapidez e algum momento a IDE travará;

outro cenário que chama atenção é:
1 - Códigos que possuem avisos do semântico. (sublinhado amarelo)

programa
{
funcao inicio()
{
teste(1,'a')
}
funcao inteiro teste(inteiro a, caracter test)
{
teste(1,'a')
}
}

A função leia não avisa que o dado informado pelo usuário é do tipo incorreto e pede novamente o valor fazendo com que o leia permaneça executando, isso prejudica a usabilidade.

Deveria acusar erro semantico dizendo que a não é um vetor; O mesmo acontece com matriz

programa
{
    funcao inicio(cadeia parametros[])
    {
        inteiro a
        leia(a[1])
        escreva(a)
    }
}

Se a inicialização da variável for uma chamada de função, o semântico acusa a variável como ão inicializada.

Ex.:

programa
{
    funcao inicio()
    {
                // Não funciona!
        real teste = 2 * multiplica(10.0, 5.0)

               // Funciona !
               //real teste = 2.0

        escreva(teste)
    }

    funcao real multiplica(real k, real f)
    {
        retorne k * f
    }
}

Ao executar o seguinte algoritmo:

programa
{
    funcao inicio(cadeia parametros[])
    {
        inteiro vetor[5] = {50, 40, 30, 20, 10}

        para (inteiro i = 0; i < tamanho(vetor); i++)
        {
//          escreva("Digite um valor: ")
//          leia(vetor[i])
        }
        para (inteiro i = 0; i < tamanho(vetor); i++)
            escreva("Vetor[", i, "] = ", vetor[i], "\n")
    }
}

A primeira execução exibe os valores 50, 40, 30, 20, 10.
A segunda execução exibe os valores 0, 0, 0, 0, 0.

No código abaixo o analisador semantico permiti declarar uma constante sem inicializa-la e permite alterar seu valor.

programa
{
    funcao inicio(cadeia parametros[])
    {
        const inteiro a 
        a = 20
        escreva(a)
    }
}

programa
{
funcao inicio()
{
inteiro a = 10
teste() = 20
}

funcao inteiro teste()
{
}
}

Construções do comando para sem o primeiro parâmetro deveriam ser validas.

Exemplo de construção com erro:

inteiro c = 10
para( ; c > 0; c--){
escreva(c)
}