@designliquido/delegua 0.32.2 → 0.33.1

package/avaliador-sintatico/dialetos/visualg/avaliador-sintatico-visualg.js

@@ -0,0 +1,731 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoVisuAlg = void 0;
+const avaliador_sintatico_base_1 = require("../../avaliador-sintatico-base");
+const declaracoes_1 = require("../../../declaracoes");
+const construtos_1 = require("../../../construtos");
+const lexador_1 = require("../../../lexador");
+const visualg_1 = __importDefault(require("../../../tipos-de-simbolos/visualg"));
+const erro_avaliador_sintatico_1 = require("../../erro-avaliador-sintatico");
+const inicio_algoritmo_1 = require("../../../declaracoes/inicio-algoritmo");
+class AvaliadorSintaticoVisuAlg extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
+    constructor() {
+        super();
+        this.blocoPrincipalIniciado = false;
+    }
+    validarSegmentoAlgoritmo() {
+        this.consumir(visualg_1.default.ALGORITMO, "Esperada expressão 'algoritmo' para inicializar programa.");
+        const descricaoAlgoritmo = this.consumir(visualg_1.default.CARACTERE, "Esperada cadeia de caracteres após palavra-chave 'algoritmo'.");
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após definição do segmento 'algoritmo'.");
+        return descricaoAlgoritmo;
+    }
+    criarVetorNDimensional(dimensoes) {
+        if (dimensoes.length > 0) {
+            const dimensao = dimensoes[0] + 1;
+            const resto = dimensoes.slice(1);
+            const novoArray = Array(dimensao);
+            for (let i = 0; i <= dimensao; i++) {
+                novoArray[i] = this.criarVetorNDimensional(resto);
+            }
+            return novoArray;
+        }
+        return undefined;
+    }
+    validarDimensoesVetor() {
+        let dimensoes = [];
+        do {
+            const numeroInicial = this.consumir(visualg_1.default.NUMERO, 'Esperado índice inicial para inicialização de dimensão de vetor.');
+            this.consumir(visualg_1.default.PONTO, 'Esperado primeiro ponto após índice inicial para inicialização de dimensão de vetor.');
+            this.consumir(visualg_1.default.PONTO, 'Esperado segundo ponto após índice inicial para inicialização de dimensão de vetor.');
+            const numeroFinal = this.consumir(visualg_1.default.NUMERO, 'Esperado índice final para inicialização de dimensão de vetor.');
+            dimensoes.push(Number(numeroFinal.literal) - Number(numeroInicial.literal));
+        } while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA));
+        return dimensoes;
+    }
+    logicaComumParametroVisuAlg() {
+        const identificadores = [];
+        let referencia = this.verificarSeSimboloAtualEIgualA(visualg_1.default.VAR);
+        do {
+            identificadores.push(this.consumir(visualg_1.default.IDENTIFICADOR, 'Esperado nome de variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA));
+        this.consumir(visualg_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de variável.');
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.CARACTER, visualg_1.default.CARACTERE, visualg_1.default.INTEIRO, visualg_1.default.LOGICO, visualg_1.default.REAL, visualg_1.default.VETOR)) {
+            throw this.erro(this.simbolos[this.atual], `Tipo de variável não conhecido: ${this.simbolos[this.atual].lexema}`);
+        }
+        const simboloAnterior = this.simbolos[this.atual - 1];
+        const tipoVariavel = simboloAnterior.tipo;
+        return {
+            identificadores,
+            tipo: tipoVariavel,
+            simbolo: simboloAnterior,
+            referencia: referencia,
+        };
+    }
+    /**
+     * Validação do segmento de declaração de variáveis (opcional).
+     * @returns Vetor de Construtos para inicialização de variáveis.
+     */
+    validarSegmentoVar() {
+        // Podem haver linhas de comentários acima de `var`, que geram
+        // quebras de linha.
+        while (this.simbolos[this.atual].tipo === visualg_1.default.QUEBRA_LINHA) {
+            this.avancarEDevolverAnterior();
+        }
+        if (!this.verificarTipoSimboloAtual(visualg_1.default.VAR)) {
+            return [];
+        }
+        const inicializacoes = [];
+        this.avancarEDevolverAnterior(); // Var
+        while (!this.verificarTipoSimboloAtual(visualg_1.default.INICIO)) {
+            // Se ainda houver quebras de linha, volta para o começo do `while`.
+            if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.QUEBRA_LINHA)) {
+                continue;
+            }
+            const simboloAtual = this.simbolos[this.atual];
+            switch (simboloAtual.tipo) {
+                case visualg_1.default.FUNCAO:
+                case visualg_1.default.FUNÇÃO:
+                    const dadosFuncao = this.funcao('funcao');
+                    inicializacoes.push(dadosFuncao);
+                    break;
+                case visualg_1.default.PROCEDIMENTO:
+                    const dadosProcedimento = this.declaracaoProcedimento();
+                    inicializacoes.push(dadosProcedimento);
+                    break;
+                default:
+                    const dadosVariaveis = this.logicaComumParametroVisuAlg();
+                    // Se chegou até aqui, variáveis são válidas.
+                    // Devem ser declaradas com um valor inicial padrão.
+                    if (dadosVariaveis.tipo === visualg_1.default.VETOR) {
+                        this.consumir(visualg_1.default.COLCHETE_ESQUERDO, 'Esperado colchete esquerdo após palavra reservada "vetor".');
+                        const dimensoes = this.validarDimensoesVetor();
+                        this.consumir(visualg_1.default.COLCHETE_DIREITO, 'Esperado colchete direito após declaração de dimensões de vetor.');
+                        this.consumir(visualg_1.default.DE, 'Esperado palavra reservada "de" após declaração de dimensões de vetor.');
+                        const simboloTipo = this.simbolos[this.atual];
+                        if (![
+                            visualg_1.default.CARACTER,
+                            visualg_1.default.CARACTERE,
+                            visualg_1.default.INTEIRO,
+                            visualg_1.default.LOGICO,
+                            visualg_1.default.REAL,
+                            visualg_1.default.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 declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), this.criarVetorNDimensional(dimensoes)), `${simboloTipo.lexema}[]`));
+                        }
+                        this.atual++;
+                    }
+                    else {
+                        for (let identificador of dadosVariaveis.identificadores) {
+                            const tipo = dadosVariaveis.tipo;
+                            switch (dadosVariaveis.tipo) {
+                                case visualg_1.default.CARACTER:
+                                case visualg_1.default.CARACTERE:
+                                    inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), ''), tipo));
+                                    break;
+                                case visualg_1.default.INTEIRO:
+                                case visualg_1.default.REAL:
+                                    inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), 0), tipo));
+                                    break;
+                                case visualg_1.default.LOGICO:
+                                    inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), false), tipo));
+                                    break;
+                            }
+                        }
+                    }
+                    break;
+            }
+            this.consumir(visualg_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após declaração de variável.');
+        }
+        return inicializacoes;
+    }
+    validarSegmentoInicio(algoritmoOuFuncao) {
+        const simboloInicio = this.consumir(visualg_1.default.INICIO, `Esperada expressão 'inicio' para marcar escopo de ${algoritmoOuFuncao}.`);
+        return simboloInicio;
+    }
+    estaNoFinal() {
+        return this.atual === this.simbolos.length;
+    }
+    metodoBibliotecaGlobal() {
+        const simboloAnterior = this.simbolos[this.atual - 1];
+        switch (simboloAnterior.lexema) {
+            case 'int':
+                return new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(visualg_1.default.IDENTIFICADOR, 'inteiro', null, Number(simboloAnterior.linha), this.hashArquivo)), null, []);
+            default:
+                return null;
+        }
+    }
+    primario() {
+        const simboloAtual = this.simbolos[this.atual];
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.FALSO))
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VERDADEIRO))
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
+        if (simboloAtual.lexema === 'limpatela') {
+            const variavel = new construtos_1.Variavel(this.hashArquivo, simboloAtual);
+            this.avancarEDevolverAnterior();
+            return new construtos_1.Chamada(this.hashArquivo, variavel, null, []);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.IDENTIFICADOR, visualg_1.default.METODO_BIBLIOTECA_GLOBAL)) {
+            return new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.NUMERO, visualg_1.default.CARACTER, visualg_1.default.CARACTERE)) {
+            const simboloAnterior = this.simbolos[this.atual - 1];
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO)) {
+            const expressao = this.expressao();
+            this.consumir(visualg_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+            return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+        }
+        throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.DIFERENTE, visualg_1.default.IGUAL)) {
+            const simboloAnterior = this.simbolos[this.atual - 1];
+            const direito = this.comparar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, simboloAnterior, direito);
+        }
+        return expressao;
+    }
+    ou() {
+        let expressao = this.e();
+        while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.OU, visualg_1.default.XOU)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.e();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    /**
+     * Método que resolve atribuições.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
+     */
+    atribuir() {
+        const expressao = this.ou();
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.SETA_ATRIBUICAO)) {
+            const setaAtribuicao = this.simbolos[this.atual - 1];
+            const valor = this.atribuir();
+            if (expressao instanceof construtos_1.Variavel) {
+                const simbolo = expressao.simbolo;
+                return new construtos_1.Atribuir(this.hashArquivo, simbolo, valor);
+            }
+            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, valor);
+            }
+            else if (expressao instanceof construtos_1.AcessoElementoMatriz) {
+                return new construtos_1.AtribuicaoPorIndicesMatriz(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indicePrimario, expressao.indiceSecundario, valor);
+            }
+            this.erro(setaAtribuicao, 'Tarefa de atribuição inválida');
+        }
+        return expressao;
+    }
+    expressao() {
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.LEIA))
+            return this.declaracaoLeia();
+        return this.atribuir();
+    }
+    blocoEscopo() {
+        const declaracoes = [];
+        while (![visualg_1.default.FIM_FUNCAO, visualg_1.default.FIM_FUNÇÃO, visualg_1.default.FIM_PROCEDIMENTO].includes(this.simbolos[this.atual].tipo) &&
+            !this.estaNoFinal()) {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        }
+        // Se chegou até aqui, simplesmente consome o símbolo.
+        this.avancarEDevolverAnterior();
+        // this.consumir(tiposDeSimbolos.FIM_FUNCAO, "Esperado palavra-chave 'fimfuncao' após o bloco.");
+        return declaracoes;
+    }
+    chamar() {
+        let expressao = this.primario();
+        while (true) {
+            if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO)) {
+                expressao = this.finalizarChamada(expressao);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.COLCHETE_ESQUERDO)) {
+                const indices = [];
+                do {
+                    indices.push(this.expressao());
+                } while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA));
+                const simboloFechamento = this.consumir(visualg_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                if (!indices[1]) {
+                    expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indices[0], simboloFechamento);
+                }
+                else {
+                    expressao = new construtos_1.AcessoElementoMatriz(this.hashArquivo, expressao, indices[0], indices[1], simboloFechamento);
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return expressao;
+    }
+    simboloAtual() {
+        return this.simbolos[this.atual - 2];
+    }
+    verificarDefinicaoTipoAtual() {
+        const tipos = ['inteiro', 'qualquer', 'real', 'texto', 'vazio', 'vetor', 'caracter'];
+        const lexema = this.simboloAtual().lexema.toLowerCase();
+        const contemTipo = tipos.find((tipo) => tipo === lexema);
+        if (contemTipo && this.verificarTipoProximoSimbolo(visualg_1.default.COLCHETE_ESQUERDO)) {
+            const tiposVetores = ['inteiro[]', 'qualquer[]', 'real[]', 'texto[]', 'caracter[]'];
+            this.avancarEDevolverAnterior();
+            if (!this.verificarTipoProximoSimbolo(visualg_1.default.COLCHETE_DIREITO)) {
+                throw this.erro(this.simbolos[this.atual - 1], "Esperado símbolo de fechamento do vetor ']'.");
+            }
+            const contemTipoVetor = tiposVetores.find((tipo) => tipo === `${lexema}[]`);
+            this.avancarEDevolverAnterior();
+            return contemTipoVetor;
+        }
+        return contemTipo;
+    }
+    corpoDaFuncao(tipo) {
+        const simboloAnterior = this.simbolos[this.atual - 1];
+        // Parâmetros
+        const parametros = this.logicaComumParametros();
+        this.consumir(visualg_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de função.');
+        // Tipo retornado pela função.
+        let tipoRetorno = null;
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.INTEIRO, visualg_1.default.CARACTER, visualg_1.default.CARACTERE, visualg_1.default.REAL, visualg_1.default.LOGICO)) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado um tipo válido para retorno de função');
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após tipo retornado por 'funcao'.");
+        tipoRetorno = this.verificarDefinicaoTipoAtual();
+        const inicializacoes = this.validarSegmentoVar();
+        this.validarSegmentoInicio('função');
+        const corpo = inicializacoes.concat(this.blocoEscopo());
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloAnterior.linha), parametros, corpo.filter((d) => d), tipoRetorno);
+    }
+    declaracaoEnquanto() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.FACA, visualg_1.default.FAÇA)) {
+            this.consumir(this.simbolos[this.atual].tipo, "Esperado paravra reservada 'faca' ou 'faça' após condição de continuidade em declaracão 'enquanto'.");
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra reservada 'faca' em declaracão 'enquanto'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (![visualg_1.default.FIM_ENQUANTO].includes(this.simbolos[this.atual].tipo));
+        this.consumir(visualg_1.default.FIM_ENQUANTO, "Esperado palavra-chave 'fimenquanto' para fechamento de declaração 'enquanto'.");
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimenquanto'.");
+        return new declaracoes_1.Enquanto(condicao, new declaracoes_1.Bloco(simboloAtual.hashArquivo, Number(simboloAtual.linha), declaracoes.filter((d) => d)));
+    }
+    logicaCasosEscolha() {
+        const literais = [];
+        let simboloAtualCaso = this.simbolos[this.atual];
+        while (simboloAtualCaso.tipo !== visualg_1.default.QUEBRA_LINHA) {
+            literais.push(this.primario());
+            this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA);
+            simboloAtualCaso = this.simbolos[this.atual];
+        }
+        return literais;
+    }
+    declaracaoEscolha() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        // Parênteses são opcionais para delimitar o identificador.
+        this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO);
+        const identificador = this.primario();
+        this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_DIREITO);
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após variável ou literal de declaração 'caso'.");
+        while (this.simbolos[this.atual].tipo === visualg_1.default.QUEBRA_LINHA) {
+            this.avancarEDevolverAnterior();
+        }
+        // Blocos de caso
+        const caminhos = [];
+        let simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
+        while (![visualg_1.default.OUTRO_CASO, visualg_1.default.FIM_ESCOLHA].includes(simboloAtualBlocoCaso.tipo)) {
+            const caminhoCondicoes = this.logicaCasosEscolha();
+            const declaracoes = [];
+            do {
+                declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            } while (![visualg_1.default.CASO, visualg_1.default.OUTRO_CASO, visualg_1.default.FIM_ESCOLHA].includes(this.simbolos[this.atual].tipo));
+            caminhos.push({
+                condicoes: caminhoCondicoes.filter((c) => c),
+                declaracoes: declaracoes.filter((d) => d),
+            });
+            while (this.simbolos[this.atual].tipo === visualg_1.default.QUEBRA_LINHA) {
+                this.avancarEDevolverAnterior();
+            }
+            simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
+        }
+        let caminhoPadrao = null;
+        if (simboloAtualBlocoCaso.tipo === visualg_1.default.OUTRO_CASO) {
+            const declaracoes = [];
+            do {
+                declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            } while (!this.verificarTipoSimboloAtual(visualg_1.default.FIM_ESCOLHA));
+            caminhoPadrao = {
+                declaracoes: declaracoes.filter((d) => d),
+            };
+            simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
+        }
+        if (simboloAtualBlocoCaso.tipo !== visualg_1.default.FIM_ESCOLHA) {
+            throw this.erro(this.simbolos[this.atual], "Esperado palavra-chave 'fimescolha' para fechamento de declaração 'escolha'.");
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimescolha'.");
+        return new declaracoes_1.Escolha(identificador, caminhos, caminhoPadrao);
+    }
+    logicaComumEscreva() {
+        const simboloParenteses = this.consumir(visualg_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        const argumentos = [];
+        // Sem não houver parâmetros, retorna vetor com literal vazio.
+        if (this.simbolos[this.atual].tipo === visualg_1.default.PARENTESE_DIREITO) {
+            this.avancarEDevolverAnterior();
+            return [
+                new construtos_1.FormatacaoEscrita(this.hashArquivo, Number(simboloParenteses.linha), new construtos_1.Literal(this.hashArquivo, Number(simboloParenteses.linha), '')),
+            ];
+        }
+        do {
+            const valor = this.expressao();
+            let espacos = 0;
+            let casasDecimais = 0;
+            if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.DOIS_PONTOS)) {
+                // Espaços
+                const simboloEspacos = this.consumir(visualg_1.default.NUMERO, 'Esperado número após sinal de dois-pontos após identificador como argumento.');
+                espacos = Number(simboloEspacos.lexema) - 1;
+            }
+            if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.DOIS_PONTOS)) {
+                // Casas decimais
+                const simboloCasasDecimais = this.consumir(visualg_1.default.NUMERO, 'Esperado número após segundo sinal de dois-pontos após identificador como argumento.');
+                casasDecimais = Number(simboloCasasDecimais.lexema);
+            }
+            argumentos.push(new construtos_1.FormatacaoEscrita(this.hashArquivo, Number(simboloParenteses.linha), valor, espacos, casasDecimais));
+        } while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA));
+        this.consumir(visualg_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após fechamento de parênteses pós instrução 'escreva'.");
+        return argumentos;
+    }
+    declaracaoEscreva() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const argumentos = this.logicaComumEscreva();
+        return new declaracoes_1.Escreva(Number(simboloAtual.linha), this.hashArquivo, argumentos);
+    }
+    declaracaoEscrevaMesmaLinha() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const argumentos = this.logicaComumEscreva();
+        return new declaracoes_1.EscrevaMesmaLinha(Number(simboloAtual.linha), this.hashArquivo, argumentos);
+    }
+    /**
+     * Criação de declaração "repita".
+     * @returns Um construto do tipo Fazer
+     */
+    declaracaoFazer() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após instrução 'repita'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (![visualg_1.default.ATE, visualg_1.default.ATÉ].includes(this.simbolos[this.atual].tipo));
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.ATE, visualg_1.default.ATÉ)) {
+            this.consumir(this.simbolos[this.atual].tipo, "Esperado palavra-chave 'ate' ou 'até' após declaração de bloco em instrução 'repita'.");
+        }
+        const condicao = this.expressao();
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após condição de continuidade em instrução 'repita'.");
+        return new declaracoes_1.Fazer(this.hashArquivo, Number(simboloAtual.linha), new declaracoes_1.Bloco(this.hashArquivo, Number(simboloAtual.linha), declaracoes.filter((d) => d)), condicao);
+    }
+    /**
+     * Criação de declaração "interrompa".
+     * Em VisuAlg, "sustar" é chamada de "interrompa".
+     * @returns Uma declaração do tipo Sustar.
+     */
+    declaracaoInterrompa() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        // TODO: Contar blocos para colocar esta condição de erro.
+        /* if (this.blocos < 1) {
+            this.erro(this.simbolos[this.atual - 1], "'interrompa' deve estar dentro de um laço de repetição.");
+        } */
+        return new declaracoes_1.Sustar(simboloAtual);
+    }
+    /**
+     * Análise de uma declaração `leia()`. No VisuAlg, `leia()` aceita 1..N argumentos.
+     * @returns Uma declaração `Leia`.
+     */
+    declaracaoLeia() {
+        const simboloLeia = this.avancarEDevolverAnterior();
+        this.consumir(visualg_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes do argumento em instrução `leia`.");
+        const argumentos = [];
+        do {
+            argumentos.push(this.expressao());
+        } while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.VIRGULA));
+        this.consumir(visualg_1.default.PARENTESE_DIREITO, "Esperado ')' após o argumento em instrução `leia`.");
+        this.consumir(visualg_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após fechamento de parênteses pós instrução `leia`.');
+        return new declaracoes_1.Leia(simboloLeia, argumentos);
+    }
+    declaracaoPara() {
+        const simboloPara = this.avancarEDevolverAnterior();
+        const variavelIteracao = this.consumir(visualg_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.DE, visualg_1.default.SETA_ATRIBUICAO)) {
+            throw this.erro(this.simbolos[this.atual], "Esperado palavra reservada 'de' ou seta de atribuição após variável de controle de 'para'.");
+        }
+        const literalOuVariavelInicio = this.adicaoOuSubtracao();
+        this.consumir(visualg_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
+        const literalOuVariavelFim = this.adicaoOuSubtracao();
+        let operadorCondicao = new lexador_1.Simbolo(visualg_1.default.MENOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
+        let operadorCondicaoIncremento = new lexador_1.Simbolo(visualg_1.default.MENOR, '', '', Number(simboloPara.linha), this.hashArquivo);
+        // Isso existe porque o laço `para` do VisuAlg pode ter o passo positivo ou negativo
+        // dependendo dos operandos de início e fim, que só são possíveis de determinar
+        // em tempo de execução.
+        // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
+        // passo são considerados indefinidos aqui.
+        let passo;
+        let resolverIncrementoEmExecucao = false;
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PASSO)) {
+            passo = this.unario();
+            if (passo.hasOwnProperty('operador') && passo.operador.tipo === visualg_1.default.SUBTRACAO) {
+                operadorCondicao = new lexador_1.Simbolo(visualg_1.default.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
+                operadorCondicaoIncremento = new lexador_1.Simbolo(visualg_1.default.MAIOR, '', '', Number(simboloPara.linha), this.hashArquivo);
+            }
+        }
+        else {
+            if (literalOuVariavelInicio instanceof construtos_1.Literal && literalOuVariavelFim instanceof construtos_1.Literal) {
+                if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
+                    passo = new construtos_1.Unario(this.hashArquivo, new lexador_1.Simbolo(visualg_1.default.SUBTRACAO, '-', undefined, simboloPara.linha, simboloPara.hashArquivo), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1), 'ANTES');
+                    operadorCondicao = new lexador_1.Simbolo(visualg_1.default.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
+                    operadorCondicaoIncremento = new lexador_1.Simbolo(visualg_1.default.MAIOR, '', '', Number(simboloPara.linha), this.hashArquivo);
+                }
+                else {
+                    passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
+                }
+            }
+            else {
+                // Passo e operador de condição precisam ser resolvidos em tempo de execução.
+                passo = undefined;
+                operadorCondicao = undefined;
+                operadorCondicaoIncremento = undefined;
+                resolverIncrementoEmExecucao = true;
+            }
+        }
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.FACA, visualg_1.default.FAÇA)) {
+            this.consumir(this.simbolos[this.atual].tipo, "Esperado palavra reservada 'faca' ou 'faça' após valor final do laço de repetição 'para'.");
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra reservada 'faca' do laço de repetição 'para'.");
+        const declaracoesBlocoPara = [];
+        let simboloAtualBlocoPara = this.simbolos[this.atual];
+        while (simboloAtualBlocoPara.tipo !== visualg_1.default.FIM_PARA) {
+            declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
+            simboloAtualBlocoPara = this.simbolos[this.atual];
+        }
+        this.consumir(visualg_1.default.FIM_PARA, '');
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra reservada 'fimpara'.");
+        const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloPara.linha) + 1, declaracoesBlocoPara.filter((d) => d));
+        const para = new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), 
+        // Inicialização.
+        new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, literalOuVariavelInicio), 
+        // Condição.
+        new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicao, literalOuVariavelFim), 
+        // Incremento, feito em construto especial `FimPara`.
+        new construtos_1.FimPara(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicaoIncremento, literalOuVariavelFim), new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), new lexador_1.Simbolo(visualg_1.default.ADICAO, '', null, Number(simboloPara.linha), this.hashArquivo), passo)))), corpo);
+        para.blocoPosExecucao = corpo;
+        para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
+        return para;
+    }
+    logicaComumParametros() {
+        const parametros = [];
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO)) {
+            while (!this.verificarTipoSimboloAtual(visualg_1.default.PARENTESE_DIREITO)) {
+                const dadosParametros = this.logicaComumParametroVisuAlg();
+                const tipoDadoParametro = {
+                    nome: dadosParametros.simbolo.lexema,
+                    tipo: dadosParametros.tipo,
+                    tipoInvalido: !dadosParametros.tipo ? this.simboloAtual().lexema : null,
+                };
+                for (let parametro of dadosParametros.identificadores) {
+                    parametros.push({
+                        abrangencia: 'padrao',
+                        nome: parametro,
+                        referencia: dadosParametros.referencia,
+                        tipoDado: tipoDadoParametro,
+                    });
+                }
+            }
+            // Consumir parêntese direito
+            this.consumir(visualg_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito para finalização da leitura de parâmetros.');
+        }
+        return parametros;
+    }
+    /**
+     * Procedimentos nada mais são do que funções que não retornam valor.
+     */
+    declaracaoProcedimento() {
+        const simboloProcedimento = this.avancarEDevolverAnterior();
+        const nomeProcedimento = this.consumir(visualg_1.default.IDENTIFICADOR, 'Esperado nome do procedimento após palavra-chave `procedimento`.');
+        // Parâmetros
+        const parametros = this.logicaComumParametros();
+        const inicializacoes = this.validarSegmentoVar();
+        this.validarSegmentoInicio('procedimento');
+        const corpo = inicializacoes.concat(this.blocoEscopo());
+        return new declaracoes_1.FuncaoDeclaracao(nomeProcedimento, new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloProcedimento.linha), parametros, corpo.filter((d) => d)));
+    }
+    declaracaoRetorna() {
+        const simboloRetorna = this.avancarEDevolverAnterior();
+        let valor = null;
+        if ([
+            visualg_1.default.CARACTER,
+            visualg_1.default.CARACTERE,
+            visualg_1.default.IDENTIFICADOR,
+            visualg_1.default.NUMERO,
+            visualg_1.default.VERDADEIRO,
+            visualg_1.default.NEGACAO,
+            visualg_1.default.FALSO,
+            visualg_1.default.PARENTESE_ESQUERDO,
+        ].includes(this.simbolos[this.atual].tipo)) {
+            valor = this.expressao();
+        }
+        return new declaracoes_1.Retorna(simboloRetorna, valor);
+    }
+    declaracaoSe() {
+        const simboloSe = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.ENTAO, visualg_1.default.ENTÃO)) {
+            this.consumir(this.simbolos[this.atual].tipo, "Esperado palavra reservada 'entao' ou 'então' após condição em declaração 'se'.");
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra reservada 'entao' em declaração 'se'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (![visualg_1.default.SENAO, visualg_1.default.SENÃO, visualg_1.default.FIM_SE].includes(this.simbolos[this.atual].tipo));
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.SENAO, visualg_1.default.SENÃO)) {
+            const simboloSenao = this.simbolos[this.atual - 1];
+            const declaracoesSenao = [];
+            do {
+                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
+            } while (![visualg_1.default.FIM_SE].includes(this.simbolos[this.atual].tipo));
+            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
+        }
+        this.consumir(visualg_1.default.FIM_SE, "Esperado palavra-chave 'fimse' para fechamento de declaração 'se'.");
+        this.consumir(visualg_1.default.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimse'.");
+        return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
+    }
+    declaracaoAleatorio() {
+        const simboloAleatorio = this.avancarEDevolverAnterior();
+        let argumentos = {
+            min: 0,
+            max: 0,
+        };
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.NUMERO)) {
+            this.consumir(visualg_1.default.VIRGULA, "Esperado ',' após declaração do primeiro número.");
+            argumentos.min = Number(this.simboloAtual().literal);
+            this.consumir(visualg_1.default.NUMERO, "Esperado um número após ','.");
+            argumentos.max = Number(this.simbolos[this.atual - 1].literal);
+        }
+        else if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.ON)) {
+            this.consumir(simboloAleatorio.tipo, "Esperado palavra reservada 'ON'ou 'on' ou combinação de número'(min, max)' após declaração 'aleatorio'");
+            argumentos = null;
+        }
+        this.consumir(visualg_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após declaração do último número.');
+        const decoracoes = [];
+        do {
+            const decoracao = this.resolverDeclaracaoForaDeBloco();
+            if (decoracao instanceof declaracoes_1.Leia)
+                decoracao.eParaInterromper = true;
+            decoracoes.push(decoracao);
+        } while (![visualg_1.default.ALEATORIO, visualg_1.default.FIM_ALGORITMO].includes(this.simbolos[this.atual].tipo));
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.ALEATORIO)) {
+            this.consumir(visualg_1.default.OFF, "Esperado palavra reservada 'off' ou 'OFF' após declaração 'aleatorio'.");
+        }
+        return new declaracoes_1.Aleatorio(simboloAleatorio.linha, simboloAleatorio.hashArquivo, new declaracoes_1.Bloco(simboloAleatorio.hashArquivo, Number(simboloAleatorio.linha), decoracoes.filter((d) => d)), argumentos);
+    }
+    resolverDeclaracaoForaDeBloco() {
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            case visualg_1.default.ALEATORIO:
+                return this.declaracaoAleatorio();
+            case visualg_1.default.ENQUANTO:
+                return this.declaracaoEnquanto();
+            case visualg_1.default.ESCOLHA:
+                return this.declaracaoEscolha();
+            case visualg_1.default.ESCREVA:
+                return this.declaracaoEscrevaMesmaLinha();
+            case visualg_1.default.ESCREVA_LINHA:
+                return this.declaracaoEscreva();
+            case visualg_1.default.FUNCAO:
+                return this.funcao('funcao');
+            case visualg_1.default.INICIO:
+                const simboloInicio = this.validarSegmentoInicio('algoritmo');
+                return new inicio_algoritmo_1.InicioAlgoritmo(simboloInicio.linha, simboloInicio.hashArquivo);
+            case visualg_1.default.INTERROMPA:
+                return this.declaracaoInterrompa();
+            case visualg_1.default.LEIA:
+                return this.declaracaoLeia();
+            case visualg_1.default.PARA:
+                return this.declaracaoPara();
+            case visualg_1.default.PARENTESE_DIREITO:
+                throw new Error('Não deveria estar caindo aqui.');
+            case visualg_1.default.PROCEDIMENTO:
+                return this.declaracaoProcedimento();
+            case visualg_1.default.QUEBRA_LINHA:
+                this.avancarEDevolverAnterior();
+                return null;
+            case visualg_1.default.REPITA:
+                return this.declaracaoFazer();
+            case visualg_1.default.RETORNE:
+                return this.declaracaoRetorna();
+            case visualg_1.default.SE:
+                return this.declaracaoSe();
+            case visualg_1.default.VAR:
+                if (this.blocoPrincipalIniciado) {
+                    throw this.erro(this.simbolos[this.atual], 'Sintaxe incorreta: início do bloco principal já foi declarado.');
+                }
+                return this.validarSegmentoVar();
+            default:
+                return new declaracoes_1.Expressao(this.expressao());
+        }
+    }
+    /**
+     * No VisuAlg, há uma determinada cadência de validação de símbolos.
+     * - O primeiro símbolo é `algoritmo`, seguido por um identificador e
+     * uma quebra de linha.
+     * - Os próximos símbolo pode `var`, que pode ser seguido por uma série de
+     * declarações de variáveis e finalizado por uma quebra de linha,
+     * ou ainda `funcao` ou `procedimento`, seguidos dos devidos símbolos que definem
+     * os blocos.
+     * - O penúltimo símbolo é `inicio`, seguido por uma quebra de linha.
+     * Pode haver ou não declarações dentro do bloco.
+     * - O último símbolo deve ser `fimalgoritmo`, que também é usado para
+     * definir quando não existem mais construtos a serem adicionados.
+     * @param retornoLexador Os símbolos entendidos pelo Lexador.
+     * @param hashArquivo Obrigatório por interface mas não usado aqui.
+     */
+    analisar(retornoLexador, hashArquivo) {
+        this.erros = [];
+        this.atual = 0;
+        this.blocos = 0;
+        this.blocoPrincipalIniciado = false;
+        this.hashArquivo = hashArquivo || 0;
+        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
+        while (this.verificarTipoSimboloAtual(visualg_1.default.QUEBRA_LINHA)) {
+            this.avancarEDevolverAnterior();
+        }
+        let declaracoes = [];
+        const simboloNomeAlgoritmo = this.validarSegmentoAlgoritmo();
+        declaracoes.push(new declaracoes_1.CabecalhoPrograma(simboloNomeAlgoritmo.linha, simboloNomeAlgoritmo.hashArquivo, simboloNomeAlgoritmo.literal));
+        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== visualg_1.default.FIM_ALGORITMO) {
+            const declaracao = this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(declaracao)) {
+                declaracoes = declaracoes.concat(declaracao);
+            }
+            else {
+                declaracoes.push(declaracao);
+            }
+        }
+        const ultimoSimbolo = this.simbolos[this.simbolos.length - 1];
+        if (ultimoSimbolo.tipo !== visualg_1.default.FIM_ALGORITMO) {
+            throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(ultimoSimbolo, `Programa não termina com 'fimalgoritmo'. Último símbolo: '${ultimoSimbolo.lexema || ultimoSimbolo.literal}'.`);
+        }
+        return {
+            declaracoes: declaracoes.filter((d) => d),
+            erros: this.erros,
+        };
+    }
+}
+exports.AvaliadorSintaticoVisuAlg = AvaliadorSintaticoVisuAlg;
+//# sourceMappingURL=avaliador-sintatico-visualg.js.map