Declaracao constante Portugol Studio (#601)

* Declaracao constante Portugol Studio * Corrige erros dos testes unitários
DesignLiquido · Jan 27, 2024 · 014f72f · 014f72f
1 parent 233fd6f
commit 014f72f
Show file tree

Hide file tree

Showing 2 changed files with 86 additions and 0 deletions.
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -27,6 +27,7 @@ import {
     Bloco,
     EscrevaMesmaLinha,
     Retorna,
+    Const,
 } from '../../declaracoes';
 import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
@@ -36,6 +37,7 @@ import { ParametroInterface, SimboloInterface } from '../../interfaces';
 import tiposDeSimbolos from '../../tipos-de-simbolos/portugol-studio';
 import { RetornoDeclaracao } from '../retornos';
 import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
+import { TiposDadosInterface } from '../../interfaces/tipos-dados-interface';
 
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
@@ -679,6 +681,30 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
     }
 
+    declaracaoDeConstantes(): any {
+        let identificador: SimboloInterface;
+        let tipo: SimboloInterface;
+        if (
+            [
+                tiposDeSimbolos.REAL,
+                tiposDeSimbolos.INTEIRO,
+                tiposDeSimbolos.CADEIA,
+                tiposDeSimbolos.CARACTER,
+                tiposDeSimbolos.LOGICO,
+            ].includes(this.simbolos[this.atual].tipo)
+        ) {
+            tipo = this.avancarEDevolverAnterior();
+        }
+
+        identificador = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da constante.');
+
+        this.consumir(tiposDeSimbolos.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+
+        const inicializador = this.expressao();
+
+        return new Const(identificador, inicializador, tipo.lexema as TiposDadosInterface);
+    }
+
     resolverDeclaracaoForaDeBloco(): Declaracao | Declaracao[] | Construto | Construto[] | any {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
@@ -689,6 +715,9 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
             case tiposDeSimbolos.CHAVE_ESQUERDA:
                 const simboloInicioBloco: SimboloInterface = this.simbolos[this.atual];
                 return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
+            case tiposDeSimbolos.CONSTANTE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoDeConstantes();
             case tiposDeSimbolos.ENQUANTO:
                 return this.declaracaoEnquanto();
             case tiposDeSimbolos.ESCREVA:

diff --git a/testes/portugol-studio/interpretador.test.ts b/testes/portugol-studio/interpretador.test.ts
@@ -271,6 +271,63 @@ describe('Interpretador (Portugol Studio)', () => {
 
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
+
+            it('Constante', async () => {
+                const respostas = ["Abigail", 4, 5, 10];
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(respostas.pop());
+                    }
+                };
+
+                const retornoLexador = lexador.mapear([
+                    'programa',
+                    '{',
+                        'funcao inicio ()',
+                        '{	',                            
+
+                            'const real PRECO_PARAFUSO = 1.50',
+                            'const real PRECO_ARRUELA  = 2.00',
+                            'const real PRECO_PORCA    = 2.50',
+
+                            'cadeia nome',
+                            'inteiro quantidade_parafusos, quantidade_arruelas, quantidade_porcas',
+                            'real total_parafusos, total_arruelas, total_porcas, total_pagar',
+
+                            'escreva("Digite seu nome: ")',
+                            'leia(nome)',
+
+                            'escreva("\nDigite a quantidade de parafusos que deseja comprar: ")',
+                            'leia(quantidade_parafusos)',
+
+                            'escreva("Digite a quantidade de arruelas que deseja comprar: ")',
+                            'leia(quantidade_arruelas)',
+
+                            'escreva("Digite a quantidade de porcas que deseja comprar: ")',
+                            'leia(quantidade_porcas)',
+
+                            'total_parafusos = PRECO_PARAFUSO * quantidade_parafusos',
+                            'total_arruelas = PRECO_ARRUELA * quantidade_arruelas',
+                            'total_porcas = PRECO_PORCA * quantidade_porcas',
+
+                            'total_pagar = total_parafusos + total_porcas + total_arruelas',
+
+                            'escreva("Cliente: ", nome, "\n")',
+                            'escreva("===============================\n")',
+                            'escreva("Parafusos: ", quantidade_parafusos, "\n")',
+                            'escreva("Arruelas: " , quantidade_arruelas, "\n")',
+                            'escreva("Porcas: ", quantidade_porcas, "\n")',
+                            'escreva("===============================\n")',
+                            'escreva("Total a pagar:  R$ ", total_pagar, "\n")',
+                        '}',
+                    '}',
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
         });
     });
 });