Repository: DesignLiquido/delegua
Pull request #318 (2023-04-08 01:48:50)

Mapler - Declarações de Se/Senao e Enquanto

github-actions[bot]: <!-- jest coverage report action for options with hash 781087021f8e6c43aac1e668f4520603 -->

## Coverage report 



| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | Category   | Percentage                                                     | Covered / Total |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :--------- | :------------------------------------------------------------- | :-------------: |
|                                                                           🟡                                                                           | Statements | <div title="Base coverage is: 73.04%">74.01% (+0.97% 🔼)</div> |    5311/7176    |
|                                                                           🟡                                                                           | Branches   | <div title="Base coverage is: 61.26%">62.98% (+1.72% 🔼)</div> |    1674/2658    |
|                                                                           🟡                                                                           | Functions  | <div title="Base coverage is: 74.57%">75.58% (+1.01% 🔼)</div> |     786/1040    |
|                                                                           🟡                                                                           | Lines      | <div title="Base coverage is: 73.48%">74.47% (+0.99% 🔼)</div> |    5167/6938    |


## Test suite run success
381 tests passing in 35 suites.

<p align="right">Report generated by <a href="https://github.com/ArtiomTr/jest-coverage-report-action">🧪jest coverage report action</a> from fd1688d6dff8c5f9bfb57127a2c16c1c26a6a965</p>
<!-- Sticky Pull Request Comment -->

Patch:
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
index 84252f8b..96842b7a 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
@@ -8,7 +8,6 @@ import {
     Escreva,
     EscrevaMesmaLinha,
     Fazer,
-    FuncaoDeclaracao,
     Leia,
     Para,
     Se,
@@ -30,7 +29,6 @@ import {
     Variavel,
 } from '../../construtos';
 import { SimboloInterface } from '../../interfaces';
-import { Simbolo } from '../../lexador';
 
 import tiposDeSimbolos from '../../tipos-de-simbolos/mapler';
 
@@ -201,31 +199,6 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         return this.atual === this.simbolos.length;
     }
 
-    metodoBibliotecaGlobal(): Construto {
-        const simboloAnterior = this.simbolos[this.atual - 1];
-
-        switch (simboloAnterior.lexema) {
-            case 'int':
-                return new Chamada(
-                    this.hashArquivo,
-                    new Variavel(
-                        this.hashArquivo,
-                        new Simbolo(
-                            tiposDeSimbolos.IDENTIFICADOR,
-                            'inteiro',
-                            null,
-                            Number(simboloAnterior.linha),
-                            this.hashArquivo
-                        )
-                    ),
-                    null,
-                    []
-                );
-            default:
-                return null;
-        }
-    }
-
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
 
@@ -240,7 +213,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
             return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.CARACTERE)) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.CADEIA, tiposDeSimbolos.CARACTERE)) {
             const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
             return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
@@ -366,15 +339,9 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         const simboloAnterior = this.simbolos[this.atual - 1];
         this.consumir(tiposDeSimbolos.DOIS_PONTOS, 'Esperado dois-pontos após nome de função.');
 
-        // Tipo retornado pela função.
-        if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.INTEIRO, tiposDeSimbolos.CARACTERE)) {
-            throw this.erro(this.simbolos[this.atual], 'Esperado um tipo válido para retorno de função');
-        }
-
         // this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após tipo retornado por 'funcao'.");
 
         this.validarSegmentoVariaveis();
-        // this.validarSegmentoInicio('função');
 
         const corpo = this.blocoEscopo();
 
@@ -394,14 +361,23 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         const declaracoes = [];
         do {
             declaracoes.push(this.declaracao());
-        } while (![tiposDeSimbolos.FIM_ENQUANTO].includes(this.simbolos[this.atual].tipo));
+        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
+                && ![tiposDeSimbolos.ENQUANTO].includes(this.simbolos[this.atual + 1].tipo));
 
         this.consumir(
-            tiposDeSimbolos.FIM_ENQUANTO,
-            "Esperado palavra-chave 'fimenquanto' para fechamento de declaração 'enquanto'."
+            tiposDeSimbolos.FIM,
+            "Esperado palavra-chave 'fim' para iniciar o fechamento de declaração 'enquanto'."
         );
 
-        // this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimenquanto'.");
+        this.consumir(
+            tiposDeSimbolos.ENQUANTO,
+            "Esperado palavra-chave 'enquanto' para o fechamento de declaração 'enquanto'."
+        );
+
+        this.consumir(
+            tiposDeSimbolos.PONTO_VIRGULA,
+            "Esperado palavra-chave ';' para o fechamento de declaração 'enquanto'."
+        );
 
         return new Enquanto(
             condicao, 
@@ -413,19 +389,6 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         );
     }
 
-    private logicaCasosEscolha(): any {
-        const literais = [];
-
-        let simboloAtualCaso: SimboloInterface = this.simbolos[this.atual];
-        // while (simboloAtualCaso.tipo !== tiposDeSimbolos.QUEBRA_LINHA) {
-        //     literais.push(this.primario());
-        //     this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA);
-        //     simboloAtualCaso = this.simbolos[this.atual];
-        // }
-
-        return literais;
-    }
-
     declaracaoEscolha(): Escolha {
         throw new Error('Method not implemented.');
     }
@@ -677,35 +640,45 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         const condicao = this.expressao();
 
         this.consumir(tiposDeSimbolos.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'.");
-        // this.consumir(
-        //     tiposDeSimbolos.QUEBRA_LINHA,
-        //     "Esperado quebra de linha após palavra reservada 'entao' em declaração 'se'."
-        // );
 
         const declaracoes = [];
+        let caminhoSenao = null;
+
         do {
             declaracoes.push(this.declaracao());
-        } while (![tiposDeSimbolos.SENAO, tiposDeSimbolos.FIM_SE].includes(this.simbolos[this.atual].tipo));
 
-        let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) {
-            const simboloSenao = this.simbolos[this.atual - 1];
-            const declaracoesSenao = [];
-
-            do {
-                declaracoesSenao.push(this.declaracao());
-            } while (![tiposDeSimbolos.FIM_SE].includes(this.simbolos[this.atual].tipo));
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) {
+                const simboloSenao = this.simbolos[this.atual - 1];
+                const declaracoesSenao = [];
+    
+                do {
+                    declaracoesSenao.push(this.declaracao());
+                } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
+                        && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
+    
+                caminhoSenao = new Bloco(
+                    this.hashArquivo,
+                    Number(simboloSenao.linha),
+                    declaracoesSenao.filter((d) => d)
+                );
+            }
+        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo) 
+                && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
 
-            caminhoSenao = new Bloco(
-                this.hashArquivo,
-                Number(simboloSenao.linha),
-                declaracoesSenao.filter((d) => d)
-            );
-        }
+        this.consumir(
+            tiposDeSimbolos.FIM,
+            "Esperado palavra-chave 'fim' para iniciar o fechamento de declaração 'se'."
+        );
 
-        this.consumir(tiposDeSimbolos.FIM_SE, "Esperado palavra-chave 'fimse' para fechamento de declaração 'se'.");
+        this.consumir(
+            tiposDeSimbolos.SE,
+            "Esperado palavra-chave 'se' para o fechamento de declaração 'se'."
+        );
 
-        // this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimse'.");
+        this.consumir(
+            tiposDeSimbolos.PONTO_VIRGULA,
+            "Esperado palavra-chave ';' para o fechamento de declaração 'se'."
+        );
 
         return new Se(
             condicao,
@@ -738,9 +711,6 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
             //     throw new Error('Não deveria estar caindo aqui.');
             // case tiposDeSimbolos.PROCEDIMENTO:
             //     return this.declaracaoProcedimento();
-            // case tiposDeSimbolos.QUEBRA_LINHA:
-            //     this.avancarEDevolverAnterior();
-            //     return null;
             case tiposDeSimbolos.REPITA:
                 return this.declaracaoFazer();
             case tiposDeSimbolos.SE:
diff --git a/fontes/lexador/dialetos/lexador-mapler.ts b/fontes/lexador/dialetos/lexador-mapler.ts
index 9e7171f9..c35b224b 100644
--- a/fontes/lexador/dialetos/lexador-mapler.ts
+++ b/fontes/lexador/dialetos/lexador-mapler.ts
@@ -135,10 +135,10 @@ export class LexadorMapler extends LexadorBaseLinhaUnica {
                 this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 this.avancar();
                 break;
-            case '%':
-                this.adicionarSimbolo(tiposDeSimbolos.MODULO);
-                this.avancar();
-                break;
+            // case '%':
+            //     this.adicionarSimbolo(tiposDeSimbolos.MODULO);
+            //     this.avancar();
+            //     break;
             case '*':
                 this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
                 this.avancar();


Test patch:
diff --git a/testes/mapler/interpretador.test.ts b/testes/mapler/interpretador.test.ts
index 4cfcf493..1c8ed96e 100644
--- a/testes/mapler/interpretador.test.ts
+++ b/testes/mapler/interpretador.test.ts
@@ -90,222 +90,76 @@ describe('Interpretador', () => {
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
 
-            // it("Sucesso - Enquanto", async () => {
-            //     // Aqui vamos simular a resposta para três variáveis de `leia()`.
-            //     const respostas = [
-            //         -1, -2, 1
-            //     ];
-            //     interpretador.interfaceEntradaSaida = {
-            //         question: (mensagem: string, callback: Function) => {
-            //             callback(respostas.shift());
-            //         }
-            //     };
-
-            //     const retornoLexador = lexador.mapear([
-            //         'algoritmo "teste5"',
-            //         'var',
-            //         '    num1, num2: inteiro',
-            //         '    texto1, texto2: caractere',
-            //         '    teste: logico',
-            //         'inicio',
-            //         '    teste <- verdadeiro',
-            //         '    leia (num1)',
-            //         '    escreval(teste)',
-            //         '    enquanto teste = verdadeiro faca',
-            //         '         escreval("num1 não é maior que 0")',
-            //         '         leia (num1)',
-            //         '         se num1 > 0 entao',
-            //         '             teste <- falso',
-            //         '         fimse',
-            //         '    fimenquanto',
-            //         '    escreval("num1 é maior que 0")',
-            //         'fimalgoritmo'
-            //     ], -1);
-
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
-
-            // it('Sucesso - Leia', async () => {
-            //     // Aqui vamos simular a resposta para cinco variáveis de `leia()`.
-            //     const respostas = [1, 2, 3, 4, 5];
-            //     interpretador.interfaceEntradaSaida = {
-            //         question: (mensagem: string, callback: Function) => {
-            //             callback(respostas.shift());
-            //         }
-            //     };
-
-            //     const retornoLexador = lexador.mapear([
-            //         'Algoritmo "Soma 5"',
-            //         'Var',
-            //         '    n1, n2, n3, n4, n5: inteiro',
-            //         'Inicio',
-            //         '    leia(n1, n2, n3, n4, n5)',
-            //         '    escreva(n1 + n2 + n3 + n4 + n5)',
-            //         'Fimalgoritmo'
-            //     ], -1);
-    
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
-
-            // it('Sucesso - IMC', async () => {
-            //     // Aqui vamos simular a resposta para duas variáveis de `leia()`.
-            //     const respostas = [78, 1.78];
-            //     interpretador.interfaceEntradaSaida = {
-            //         question: (mensagem: string, callback: Function) => {
-            //             callback(respostas.shift());
-            //         }
-            //     };
-
-            //     const retornoLexador = lexador.mapear([
-            //         'Algoritmo "CalculaIMC"',
-            //         '',
-            //         'Var',
-            //         '    M: Real',
-            //         '    A: Real',
-            //         '    IMC: Real',
-            //         '',
-            //         'Inicio',
-            //         '   Escreva("Massa(Kg): ")',
-            //         '   Leia(M)',
-            //         '   Escreva("Altura (m): ")',
-            //         '   Leia(A)',
-            //         '   IMC <- M / (A ^ 2)',
-            //         '   Escreval("IMC: ", IMC:5:2)',
-            //         '   Se (IMC >= 18.5) e (IMC < 25) entao',
-            //         '      Escreva("Parabens! Voce esta no seu peso ideal")',
-            //         '   senao',
-            //         '      Escreva("Voce nao esta na faixa de peso ideal")',
-            //         '   Fimse',
-            //         '',
-            //         'Fimalgoritmo'
-            //     ], -1);
-
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+            it('Enquanto', async () => {
+                const retornoLexador = lexador.mapear([
+                    "variaveis",
+                    "i: inteiro;",
+                    "inicio",
+                    "i <- 1;",
+                    "enquanto i <= 5 faca",
+                    "escrever i;",
+                    "i <- i + 1;",
+                    "fim enquanto;",
+                    "fim"
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-            // it("Sucesso - Média de Vetor", async () => {
-            //     // Aqui vamos simular a resposta para duas variáveis de `leia()`.
-            //     const respostas = [
-            //         90, 80, 50, 100, 60, 70, 75, 85, 89, 91, 
-            //         74, 79, 99, 90, 65, 78, 100, 67, 93, 88
-            //     ];
-            //     interpretador.interfaceEntradaSaida = {
-            //         question: (mensagem: string, callback: Function) => {
-            //             callback(respostas.pop());
-            //         }
-            //     };
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
 
-            //     const retornoLexador = lexador.mapear([
-            //         'algoritmo "media-vetor"',
-            //         'var',
-            //         'media:vetor[1..10] de real',
-            //         'i:inteiro',
-            //         'n1,n2:real',
-            //         'inicio',
-            //         'para i de 1 ate 10 faca',
-            //         '     escreval ("Digite a nota do",i,"º Aluno")',
-            //         '     leia (n1,n2)',
-            //         '     media[i]<-(n1+n2)/2',
-            //         'fimpara',
-            //         'escreval ("-")',
-            //         'para i de 1 ate 10 faca',
-            //         '       escreval ("Media do",i,"º aluno: ", media[i])',
-            //         'fimpara',
-            //         'fimalgoritmo'
-            //     ], -1);
+            it('Se', async () => {
+                const retornoLexador = lexador.mapear([
+                    "variaveis",
+                    "inicio",
+                    "se 10 > 5 entao",
+                    "escrever \"Olá\";",
+                    "fim se;",
+                    "fim",
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
 
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
+            it('Se/Senao', async () => {
+                const retornoLexador = lexador.mapear([
+                    "variaveis",
+                    "inicio",
+                    "se 10 > 5 entao",
+                    "escrever \"10 é maior que 5\";",
+                    "senao",
+                    "escrever \"10 não é maior que 5\";",
+                    "fim se;",
+                    "fim",
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
-            // it('Sucesso - Procedimento', async () => {
-            //     // Aqui vamos simular a resposta para duas variáveis de `leia()`.
-            //     const respostas = [
-            //         2, 3
-            //     ];
-            //     interpretador.interfaceEntradaSaida = {
-            //         question: (mensagem: string, callback: Function) => {
-            //             callback(respostas.pop());
-            //         }
-            //     };
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-            //     const retornoLexador = lexador.mapear([
-            //         'algoritmo "semnome"',
-            //         '// Função :',
-            //         '// Autor :',
-            //         '// Data : 27/02/2014',
-            //         '// Seção de Declarações ',
-            //         'var',
-            //         'a,b:inteiro',
-            //         'procedimento mostranumero (a:inteiro;b:inteiro)',
-            //         '',
-            //         'inicio',
-            //         '',
-            //         'se a > b entao',
-            //         '     escreval ("A variavel escolhida é ",a)',
-            //         'senao',
-            //         '     escreval ("A variavel escolhida é ",b)',
-            //         'fimse',
-            //         'fimprocedimento',
-            //         '',
-            //         'inicio',
-            //         'escreval ("Digite dois valores: ")',
-            //         'leia (a,b)',
-            //         'mostranumero (a,b)',
-            //         '',
-            //         'fimalgoritmo'
-            //     ], -1);
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
 
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
+            it.skip('Modulo', async () => {
+                const retornoLexador = lexador.mapear([
+                    "variaveis",
+                    "dizerOla: modulo;",
+                    "inicio",
+                    "dizerOla;",
+                    "fim",
+                    "modulo dizerOla",
+                    "escrever \"Olá, mundo!\";",
+                    "fim modulo;"
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
-            // it('Sucesso - Operadores Lógicos', async () => {
-            //     const retornoLexador = lexador.mapear([
-            //         'algoritmo "Exemplo Xou"',
-            //         'var A, B, C, resultA, resultB, resultC: logico',
-            //         'inicio',
-            //         'A <- verdadeiro',
-            //         'B <- verdadeiro',
-            //         'C <- falso',
-            //         'resultA <- A ou B',
-            //         'escreval("A ", resultA)',
-            //         'resultA <- A xou B',
-            //         'escreval("A ", resultA)',
-            //         'resultA <- nao B',
-            //         'escreval("A ", resultA)',
-            //         'resultB <- B',
-            //         'resultA <- (A e B) ou (A xou B)',
-            //         'resultB <- (A ou B) e (A e C)',
-            //         'resultC <- A ou C e B xou A e nao B',
-            //         'escreval("A ", resultA)',
-            //         'escreval("B ", resultB)',
-            //         'escreval("C ", resultC)',
-            //         'fimalgoritmo'
-            //     ], -1);
-            //     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-            //     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-            //     expect(retornoInterpretador.erros).toHaveLength(0);
-            // });
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
         });
     });
 });