Bug matrizes

fontes/construtos/matriz.ts

@@ -0,0 +1,22 @@
+import { VisitanteComumInterface } from "@designliquido/delegua";
+import { Construto } from "@designliquido/delegua/construtos";
+
+import { InterpretadorPortugolStudio } from "../interpretador";
+
+export class Matriz implements Construto {
+    linha: number;
+    hashArquivo: number;
+    dimensoes: number[];
+    valores: any;
+
+    constructor(hashArquivo: number, linha: number, dimensoes: number[], valores: any) {
+        this.linha = linha;
+        this.hashArquivo = hashArquivo;
+        this.dimensoes = dimensoes;
+        this.valores = valores;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<any> {
+        return await (visitante as InterpretadorPortugolStudio).visitarExpressaoMatriz(this);
+    }
+}

fontes/interpretador/comum.ts

@@ -8,6 +8,8 @@ import * as calendario from '../bibliotecas/calendario';
 import * as matematica from '../bibliotecas/matematica';
 import * as texto from '../bibliotecas/texto';
 import * as util from '../bibliotecas/util';
+import { Matriz } from 'fontes/construtos/matriz';
+import { InterpretadorPortugolStudio } from './interpretador-portugol-studio';
 
 function carregarBibliotecaCalendario(): DeleguaModulo {
     const metodos: { [nome: string]: FuncaoPadrao } = {
@@ -123,3 +125,30 @@ export async function visitarExpressaoLeiaComum(
         pilhaEscoposExecucao.definirVariavel(simbolo.lexema, valorLido);
     }
 }
+
+export async function visitarExpressaoMatrizComum(
+    interpretador: InterpretadorPortugolStudio, 
+    expressao: Matriz
+): Promise<any> {
+    return await resolverValoresMatriz(interpretador, expressao.valores);
+}
+
+/**
+ * Função recursiva que visita todos os valores de uma matriz.
+ * @param interpretador A instância do interpretador.
+ * @param valores A matriz de valores das dimensões ainda não resolvidas.
+ */
+async function resolverValoresMatriz(interpretador: InterpretadorPortugolStudio, valores: any[]) {
+    const valoresResolvidos = [];
+    if (valores && valores.length > 0) {
+        for (let i = 0; i < valores.length; i++) {
+            if (Array.isArray(valores[i])) {
+                valoresResolvidos.push(await resolverValoresMatriz(interpretador, valores[i]));
+            } else {
+                valoresResolvidos.push(await interpretador.avaliar(valores[i]));
+            }
+        }
+    }
+
+    return valoresResolvidos;
+}

fontes/interpretador/interpretador-portugol-studio-com-depuracao.ts

@@ -3,6 +3,7 @@ import { InterpretadorComDepuracao } from '@designliquido/delegua/interpretador/
 import { PilhaEscoposExecucaoPortugolStudio } from './pilha-escopos-execucao-portugol-studio';
 import { DeleguaModulo } from '@designliquido/delegua/estruturas';
 
+import { Matriz } from '../construtos/matriz';
 import * as comum from './comum';
 
 export class InterpretadorPortugolStudioComDepuracao extends InterpretadorComDepuracao {
@@ -28,6 +29,10 @@ export class InterpretadorPortugolStudioComDepuracao extends InterpretadorComDep
         return comum.visitarExpressaoLeiaComum(this.interfaceEntradaSaida, this.pilhaEscoposExecucao, expressao);
     }
 
+    async visitarExpressaoMatriz(expressao: Matriz): Promise<any> {
+        return comum.visitarExpressaoMatrizComum(this, expressao);
+    }
+
     /**
      * No Portugol Studio, como o bloco de execução da função `inicio` é criado
      * pelo avaliador sintático, precisamos ter uma forma aqui de avançar o

fontes/interpretador/interpretador-portugol-studio.ts

@@ -4,6 +4,7 @@ import { EscopoExecucao } from '@designliquido/delegua/interfaces/escopo-execuca
 import { EspacoVariaveis } from '@designliquido/delegua/espaco-variaveis';
 import { DeleguaModulo } from '@designliquido/delegua/estruturas';
 
+import { Matriz } from '../construtos/matriz';
 import { PilhaEscoposExecucaoPortugolStudio } from './pilha-escopos-execucao-portugol-studio';
 import * as comum from './comum';
 
@@ -35,4 +36,8 @@ export class InterpretadorPortugolStudio extends InterpretadorBase {
     async visitarExpressaoLeia(expressao: Leia): Promise<any> {
         return comum.visitarExpressaoLeiaComum(this.interfaceEntradaSaida, this.pilhaEscoposExecucao, expressao);
     }
+
+    async visitarExpressaoMatriz(expressao: Matriz): Promise<any> {
+        return comum.visitarExpressaoMatrizComum(this, expressao);
+    }
 }

testes/avaliador-sintatico.test.ts

@@ -323,6 +323,25 @@ describe('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
             });
+
+            it('Matrizes', () => {
+                const retornoLexador = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        //Declaração de uma matriz de inteiros',
+                    '        // de duas linhas e duas colunas já inicializado.',
+                    '        inteiro matriz[2][2] = {{15,22},{10,11}}',
+                    '    }',
+                    '}'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
         });
 
         describe('Casos de Falha', () => {

testes/interpretador.test.ts

@@ -439,6 +439,55 @@ describe('Interpretador (Portugol Studio)', () => {
                 expect(retornoInterpretador.erros).toHaveLength(0);
                 expect(_saidas).toBe('9');
             });
+
+            it('Matrizes', async () => {
+                let _saidas = "";
+                interpretador.funcaoDeRetornoMesmaLinha = (saida: string) => {
+                    _saidas += saida;
+                }
+
+                const retornoLexador = lexador.mapear([
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        //Declaração de uma matriz de inteiros',
+                    '        // de duas linhas e duas colunas já inicializado.',
+                    '        inteiro matriz[2][2] = {{15,22},{10,11}}',
+
+                    '        //Atribui -1 na primeira linha e segunda',
+                    '        // coluna da matriz.',
+                    '        matriz[0][1] = -1',
+
+                    '        //Imprime o valor 15 correspondente ',
+                    '        // a primeira linha e primeira coluna da matriz.',
+                    '        inteiro i = 0',
+                    '        escreva(matriz[i][0])',
+                    '        escreva("\n")',
+
+                    '        //Imprime o valor 11 correspondente  ',
+                    '        // a última linha e última coluna da matriz.',
+                    '        escreva(matriz[1][1])',
+
+                    '        //Declaração de uma matriz de reais de ',
+                    '        // duas linhas e quatro colunas.',
+                    '        real outra_matriz[2][4]',
+
+                    '        //Declaração de uma matriz de caracteres onde o tamanho',
+                    '        // de linhas e colunas são definidos pela inicialização',
+                    `        caracter jogo_velha[][] = {{'X','O','X'}`,
+                    `                                  ,{'O','X','O'}`,
+                    `                                  ,{' ',' ','X'}}`,
+                    '    }',
+                    '}'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+                expect(_saidas.length).toBeGreaterThanOrEqual(4);
+            });
         });
     });
 });