Repository: DesignLiquido/delegua
Pull request #506 (2023-09-22 07:32:36)

Corrige problema na declaração de vetores
Resolve: https://github.com/DesignLiquido/delegua/issues/501


Patch:
diff --git a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts
index e6753868..aa74d8da 100644
--- a/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.ts
@@ -178,69 +178,72 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                     const dadosVariaveis = this.logicaComumParametroVisuAlg();
                     // Se chegou até aqui, variáveis são válidas.
                     // Devem ser declaradas com um valor inicial padrão.
-                    for (let identificador of dadosVariaveis.identificadores) {
-                        switch (dadosVariaveis.tipo) {
-                            case tiposDeSimbolos.CARACTER:
-                            case tiposDeSimbolos.CARACTERE:
-                                inicializacoes.push(
-                                    new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), ''))
-                                );
-                                break;
-                            case tiposDeSimbolos.INTEIRO:
-                            case tiposDeSimbolos.REAL:
-                                inicializacoes.push(
-                                    new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), 0))
-                                );
-                                break;
-                            case tiposDeSimbolos.LOGICO:
-                                inicializacoes.push(
-                                    new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), false))
-                                );
-                                break;
-                            case tiposDeSimbolos.VETOR:
-                                // TODO: Validar vetor
-                                this.consumir(
-                                    tiposDeSimbolos.COLCHETE_ESQUERDO,
-                                    'Esperado colchete esquerdo após palavra reservada "vetor".'
-                                );
-                                const dimensoes = this.validarDimensoesVetor();
-                                this.consumir(
-                                    tiposDeSimbolos.COLCHETE_DIREITO,
-                                    'Esperado colchete direito após declaração de dimensões de vetor.'
-                                );
-                                this.consumir(
-                                    tiposDeSimbolos.DE,
-                                    'Esperado palavra reservada "de" após declaração de dimensões de vetor.'
-                                );
-
-                                const simboloTipo = this.simbolos[this.atual];
-                                if (
-                                    ![
-                                        tiposDeSimbolos.CARACTER,
-                                        tiposDeSimbolos.CARACTERE,
-                                        tiposDeSimbolos.INTEIRO,
-                                        tiposDeSimbolos.LOGICO,
-                                        tiposDeSimbolos.REAL,
-                                        tiposDeSimbolos.VETOR].includes(simboloTipo.tipo)
-                                ) {
-                                    throw this.erro(
-                                        simboloTipo,
-                                        'Tipo de variável não conhecido para inicialização de vetor.'
+                    if(dadosVariaveis.tipo === tiposDeSimbolos.VETOR) {
+                        this.consumir(
+                            tiposDeSimbolos.COLCHETE_ESQUERDO,
+                            'Esperado colchete esquerdo após palavra reservada "vetor".'
+                        );
+                        const dimensoes = this.validarDimensoesVetor();
+                        this.consumir(
+                            tiposDeSimbolos.COLCHETE_DIREITO,
+                            'Esperado colchete direito após declaração de dimensões de vetor.'
+                        );
+                        this.consumir(
+                            tiposDeSimbolos.DE,
+                            'Esperado palavra reservada "de" após declaração de dimensões de vetor.'
+                        );
+
+                        const simboloTipo = this.simbolos[this.atual];
+                        if (
+                            ![
+                                tiposDeSimbolos.CARACTER,
+                                tiposDeSimbolos.CARACTERE,
+                                tiposDeSimbolos.INTEIRO,
+                                tiposDeSimbolos.LOGICO,
+                                tiposDeSimbolos.REAL,
+                                tiposDeSimbolos.VETOR
+                            ].includes(simboloTipo.tipo)
+                        ) {
+                            throw this.erro(
+                                simboloTipo,
+                                'Tipo de variável não conhecido para inicialização de vetor.'
+                            );
+                        }
+                        for (let identificador of dadosVariaveis.identificadores) {
+                            inicializacoes.push(
+                                new Var(
+                                    identificador,
+                                    new Literal(
+                                        this.hashArquivo,
+                                        Number(dadosVariaveis.simbolo.linha),
+                                        this.criarVetorNDimensional(dimensoes)
+                                    ),
+                                    this.dicionarioTiposPrimitivos[simboloTipo.lexema.toLowerCase()]
+                                )
+                            );
+                        }
+                        this.atual++;
+                    } else {
+                        for (let identificador of dadosVariaveis.identificadores) {
+                            switch (dadosVariaveis.tipo) {
+                                case tiposDeSimbolos.CARACTER:
+                                case tiposDeSimbolos.CARACTERE:
+                                    inicializacoes.push(
+                                        new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), ''))
+                                    );
+                                    break;
+                                case tiposDeSimbolos.INTEIRO:
+                                case tiposDeSimbolos.REAL:
+                                    inicializacoes.push(
+                                        new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), 0))
+                                    );
+                                    break;
+                                case tiposDeSimbolos.LOGICO:
+                                    inicializacoes.push(
+                                        new Var(identificador, new Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), false))
                                     );
-                                }
-                                inicializacoes.push(
-                                    new Var(
-                                        identificador,
-                                        new Literal(
-                                            this.hashArquivo,
-                                            Number(dadosVariaveis.simbolo.linha),
-                                            this.criarVetorNDimensional(dimensoes)
-                                        ),
-                                        this.dicionarioTiposPrimitivos[simboloTipo.lexema.toLowerCase()]
-                                    )
-                                );
-                                this.atual++;
-                                break;
+                                    break;
+                            }
                         }
                     }
                     break;


Test patch:
diff --git a/testes/visualg/interpretador.test.ts b/testes/visualg/interpretador.test.ts
index 2ef6707e..7835f235 100644
--- a/testes/visualg/interpretador.test.ts
+++ b/testes/visualg/interpretador.test.ts
@@ -300,6 +300,55 @@ describe('Interpretador', () => {
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
 
+            it("Sucesso - Declaração de Vetores", async () => {
+                const retornoLexador = lexador.mapear([
+                    'algoritmo "teste"',
+                    'var',
+                    'result_j1, result_j2 : vetor[1..2] de inteiro',
+                    'inicio',
+                    'fimalgoritmo'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            //TODO: https://github.com/DesignLiquido/delegua/issues/503
+            it.skip("Sucesso - Matriz - Jogo da Velha", async () => {
+                const retornoLexador = lexador.mapear([
+                    'Algoritmo "Jogo da Velha"',
+                    'Var',
+                        'i, q, t: inteiro',
+                        'jogoMatriz : vetor [1..3, 1..3] de caractere',
+                    'Inicio',
+                        'q <- 4',
+                       't <- 7',
+                       'para i de 1 ate 3 faca',
+                          'jogoMatriz[1,i] <- numpcarac(i)',
+                          'jogoMatriz[2,i] <- numpcarac(q)',
+                          'jogoMatriz[3,i] <- numpcarac(t)',
+                          'q <- q + 1',
+                          't <- t + 1',
+                       'fimpara',
+
+                       'Escreval("      | ", jogoMatriz[1,1], " | ", jogoMatriz[1,2], " | ", jogoMatriz[1,3], " |")',
+                       'Escreval("      +---+---+---+")',
+                       'Escreval("      | ", jogoMatriz[2,1], " | ", jogoMatriz[2,2], " | ", jogoMatriz[2,3], " |")',
+                       'Escreval("      +---+---+---+")',
+                       'Escreval("      | ", jogoMatriz[3,1], " | ", jogoMatriz[3,2], " | ", jogoMatriz[3,3], " |")',
+                    'Fimalgoritmo'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
             it('Sucesso - Para com passo negativo', async () => {
                 // Aqui vamos simular a resposta para uma variável de `leia()`.
                 const respostas = [