@designliquido/delegua 0.14.6 → 0.15.0

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

@@ -1,535 +1,535 @@
-"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"));
-class AvaliadorSintaticoVisuAlg extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
-    validarSegmentoAlgoritmo() {
-        this.consumir(visualg_1.default.ALGORITMO, "Esperada expressão 'algoritmo' para inicializar programa.");
-        this.consumir(visualg_1.default.CARACTERE, "Esperad 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'.");
-    }
-    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;
-        }
-        else {
-            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 = [];
-        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.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.');
-        }
-        const simboloAnterior = this.simbolos[this.atual - 1];
-        const tipoVariavel = simboloAnterior.tipo;
-        return {
-            identificadores,
-            tipo: tipoVariavel,
-            simbolo: simboloAnterior
-        };
-    }
-    /**
-     * 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
-        // Quebra de linha é opcional aqui.
-        // this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.QUEBRA_LINHA);
-        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.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.
-                    for (let identificador of dadosVariaveis.identificadores) {
-                        switch (dadosVariaveis.tipo) {
-                            case visualg_1.default.CARACTERE:
-                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), '')));
-                                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)));
-                                break;
-                            case visualg_1.default.LOGICO:
-                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), false)));
-                                break;
-                            case visualg_1.default.VETOR:
-                                // TODO: Validar 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.');
-                                if (!this.verificarSeSimboloAtualEIgualA(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 para inicialização de vetor.');
-                                }
-                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), this.criarVetorNDimensional(dimensoes))));
-                                break;
-                        }
-                    }
-                    break;
-            }
-            this.consumir(visualg_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após declaração de variável.');
-        }
-        return inicializacoes;
-    }
-    validarSegmentoInicio(algoritmoOuFuncao) {
-        this.consumir(visualg_1.default.INICIO, `Esperada expressão 'inicio' para marcar escopo de ${algoritmoOuFuncao}.`);
-    }
-    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 (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.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);
-        }
-    }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.DIFERENTE, visualg_1.default.IGUAL)) {
-            // TODO: Este é um caso que o interpretador não deveria ter conhecimento
-            // do que é um símbolo.
-            // Em VisuAlg não existe '==', apenas '=', já que o símbolo de atribuição
-            // é uma seta: '<-'.
-            const simboloAnterior = this.simbolos[this.atual - 1];
-            let operador = new lexador_1.Simbolo('IGUAL_IGUAL', '=', null, this.hashArquivo, Number(simboloAnterior.linha));
-            if (simboloAnterior.tipo === visualg_1.default.DIFERENTE) {
-                operador = simboloAnterior;
-            }
-            const direito = this.comparar();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    /**
-     * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
-     */
-    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.AtribuicaoSobrescrita(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, 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_PROCEDIMENTO
-        ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) {
-            declaracoes.push(this.declaracao());
-        }
-        // 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 indice = indices[0];
-                const simboloFechamento = this.consumir(visualg_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
-                expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
-            }
-            else {
-                break;
-            }
-        }
-        return expressao;
-    }
-    corpoDaFuncao(tipo) {
-        const simboloAnterior = this.simbolos[this.atual - 1];
-        this.consumir(visualg_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de função.');
-        // Tipo retornado pela função.
-        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.INTEIRO, visualg_1.default.CARACTERE)) {
-            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'.");
-        this.validarSegmentoVar();
-        this.validarSegmentoInicio('função');
-        const corpo = this.blocoEscopo();
-        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloAnterior.linha), null, corpo);
-    }
-    declaracaoEnquanto() {
-        const simboloAtual = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
-        this.consumir(visualg_1.default.FACA, "Esperado paravra reservada 'faca' 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.declaracao());
-        } 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, declaracoes);
-    }
-    logicaCasosEscolha() {
-        const literais = [];
-        // let simboloAtualCaso: SimboloInterface = this.avancarEDevolverAnterior();
-        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.avancarEDevolverAnterior();
-        }
-        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'.");
-        // 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();
-            /* this.consumir(
-                tiposDeSimbolos.QUEBRA_LINHA,
-                "Esperado quebra de linha após último valor de declaração 'caso'."
-            ); */
-            const declaracoes = [];
-            do {
-                declaracoes.push(this.declaracao());
-            } 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),
-            });
-            simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
-        }
-        let caminhoPadrao = null;
-        if (simboloAtualBlocoCaso.tipo === visualg_1.default.OUTRO_CASO) {
-            const declaracoes = [];
-            do {
-                declaracoes.push(this.declaracao());
-            } 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.declaracao();
-            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.declaracao());
-        } while (![visualg_1.default.ATE].includes(this.simbolos[this.atual].tipo));
-        this.consumir(visualg_1.default.ATE, "Esperado palavra-chave 'ate' 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 simboloAtual = this.avancarEDevolverAnterior();
-        this.consumir(visualg_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes do argumento em instrução `leia`.");
-        const argumentos = [];
-        do {
-            argumentos.push(this.declaracao());
-        } 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(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
-    }
-    declaracaoPara() {
-        const simboloPara = this.avancarEDevolverAnterior();
-        const variavelIteracao = this.consumir(visualg_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
-        this.consumir(visualg_1.default.DE, "Esperado palavra reservada 'de' após variáve de controle de 'para'.");
-        const numeroInicio = this.consumir(visualg_1.default.NUMERO, "Esperado literal ou variável após 'de' em declaração 'para'.");
-        this.consumir(visualg_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
-        const numeroFim = this.consumir(visualg_1.default.NUMERO, "Esperado literal ou variável após 'de' em declaração 'para'.");
-        this.consumir(visualg_1.default.FACA, "Esperado palavra reservada 'faca' 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.declaracao());
-            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));
-        return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), numeroInicio.literal)), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), new lexador_1.Simbolo(visualg_1.default.MENOR, '', '', Number(simboloPara.linha), this.hashArquivo), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), numeroFim.literal)), 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), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1))), corpo);
-    }
-    logicaComumParametros() {
-        const parametros = [];
-        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO)) {
-            while (!this.verificarTipoSimboloAtual(visualg_1.default.PARENTESE_DIREITO)) {
-                const dadosParametros = this.logicaComumParametroVisuAlg();
-                for (let parametro of dadosParametros.identificadores) {
-                    parametros.push({
-                        tipo: 'padrao',
-                        nome: parametro
-                    });
-                }
-            }
-            // 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();
-        this.validarSegmentoVar();
-        this.validarSegmentoInicio('procedimento');
-        const corpo = this.blocoEscopo();
-        return new declaracoes_1.FuncaoDeclaracao(nomeProcedimento, new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloProcedimento.linha), parametros, corpo.filter(d => d)));
-    }
-    declaracaoSe() {
-        const simboloSe = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
-        this.consumir(visualg_1.default.ENTAO, "Esperado palavra reservada 'entao' 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.declaracao());
-        } while (![visualg_1.default.SENAO, visualg_1.default.FIM_SE].includes(this.simbolos[this.atual].tipo));
-        let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.SENAO)) {
-            const simboloSenao = this.simbolos[this.atual - 1];
-            const declaracoesSenao = [];
-            do {
-                declaracoesSenao.push(this.declaracao());
-            } 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);
-    }
-    declaracao() {
-        // Refatorar isso no futuro.
-        const simboloAtual = this.simbolos[this.atual];
-        switch (simboloAtual.tipo) {
-            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.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.SE:
-                return this.declaracaoSe();
-            default:
-                return 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.
-     * - O segundo símbolo é `var`, que pode ser seguido por uma série de
-     * declarações de variáveis e finalizado por uma quebra de linha.
-     * - O terceiro símbolo é `inicio`, seguido por uma quebra de linha.
-     * - 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.hashArquivo = hashArquivo || 0;
-        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
-        let declaracoes = [];
-        this.validarSegmentoAlgoritmo();
-        declaracoes = declaracoes.concat(this.validarSegmentoVar());
-        this.validarSegmentoInicio('algoritmo');
-        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== visualg_1.default.FIM_ALGORITMO) {
-            declaracoes.push(this.declaracao());
-        }
-        return {
-            declaracoes: declaracoes.filter((d) => d),
-            erros: this.erros,
-        };
-    }
-}
-exports.AvaliadorSintaticoVisuAlg = AvaliadorSintaticoVisuAlg;
+"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"));
+class AvaliadorSintaticoVisuAlg extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
+    validarSegmentoAlgoritmo() {
+        this.consumir(visualg_1.default.ALGORITMO, "Esperada expressão 'algoritmo' para inicializar programa.");
+        this.consumir(visualg_1.default.CARACTERE, "Esperad 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'.");
+    }
+    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;
+        }
+        else {
+            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 = [];
+        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.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.');
+        }
+        const simboloAnterior = this.simbolos[this.atual - 1];
+        const tipoVariavel = simboloAnterior.tipo;
+        return {
+            identificadores,
+            tipo: tipoVariavel,
+            simbolo: simboloAnterior
+        };
+    }
+    /**
+     * 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
+        // Quebra de linha é opcional aqui.
+        // this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.QUEBRA_LINHA);
+        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.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.
+                    for (let identificador of dadosVariaveis.identificadores) {
+                        switch (dadosVariaveis.tipo) {
+                            case visualg_1.default.CARACTERE:
+                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), '')));
+                                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)));
+                                break;
+                            case visualg_1.default.LOGICO:
+                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), false)));
+                                break;
+                            case visualg_1.default.VETOR:
+                                // TODO: Validar 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.');
+                                if (!this.verificarSeSimboloAtualEIgualA(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 para inicialização de vetor.');
+                                }
+                                inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(dadosVariaveis.simbolo.linha), this.criarVetorNDimensional(dimensoes))));
+                                break;
+                        }
+                    }
+                    break;
+            }
+            this.consumir(visualg_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após declaração de variável.');
+        }
+        return inicializacoes;
+    }
+    validarSegmentoInicio(algoritmoOuFuncao) {
+        this.consumir(visualg_1.default.INICIO, `Esperada expressão 'inicio' para marcar escopo de ${algoritmoOuFuncao}.`);
+    }
+    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 (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.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);
+        }
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(visualg_1.default.DIFERENTE, visualg_1.default.IGUAL)) {
+            // TODO: Este é um caso que o interpretador não deveria ter conhecimento
+            // do que é um símbolo.
+            // Em VisuAlg não existe '==', apenas '=', já que o símbolo de atribuição
+            // é uma seta: '<-'.
+            const simboloAnterior = this.simbolos[this.atual - 1];
+            let operador = new lexador_1.Simbolo('IGUAL_IGUAL', '=', null, this.hashArquivo, Number(simboloAnterior.linha));
+            if (simboloAnterior.tipo === visualg_1.default.DIFERENTE) {
+                operador = simboloAnterior;
+            }
+            const direito = this.comparar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    /**
+     * Método que resolve atribuições.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     */
+    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.AtribuicaoSobrescrita(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, 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_PROCEDIMENTO
+        ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) {
+            declaracoes.push(this.declaracao());
+        }
+        // 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 indice = indices[0];
+                const simboloFechamento = this.consumir(visualg_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
+            }
+            else {
+                break;
+            }
+        }
+        return expressao;
+    }
+    corpoDaFuncao(tipo) {
+        const simboloAnterior = this.simbolos[this.atual - 1];
+        this.consumir(visualg_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de função.');
+        // Tipo retornado pela função.
+        if (!this.verificarSeSimboloAtualEIgualA(visualg_1.default.INTEIRO, visualg_1.default.CARACTERE)) {
+            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'.");
+        this.validarSegmentoVar();
+        this.validarSegmentoInicio('função');
+        const corpo = this.blocoEscopo();
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloAnterior.linha), null, corpo);
+    }
+    declaracaoEnquanto() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        this.consumir(visualg_1.default.FACA, "Esperado paravra reservada 'faca' 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.declaracao());
+        } 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, declaracoes);
+    }
+    logicaCasosEscolha() {
+        const literais = [];
+        // let simboloAtualCaso: SimboloInterface = this.avancarEDevolverAnterior();
+        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.avancarEDevolverAnterior();
+        }
+        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'.");
+        // 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();
+            /* this.consumir(
+                tiposDeSimbolos.QUEBRA_LINHA,
+                "Esperado quebra de linha após último valor de declaração 'caso'."
+            ); */
+            const declaracoes = [];
+            do {
+                declaracoes.push(this.declaracao());
+            } 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),
+            });
+            simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
+        }
+        let caminhoPadrao = null;
+        if (simboloAtualBlocoCaso.tipo === visualg_1.default.OUTRO_CASO) {
+            const declaracoes = [];
+            do {
+                declaracoes.push(this.declaracao());
+            } 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.declaracao();
+            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.declaracao());
+        } while (![visualg_1.default.ATE].includes(this.simbolos[this.atual].tipo));
+        this.consumir(visualg_1.default.ATE, "Esperado palavra-chave 'ate' 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 simboloAtual = this.avancarEDevolverAnterior();
+        this.consumir(visualg_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes do argumento em instrução `leia`.");
+        const argumentos = [];
+        do {
+            argumentos.push(this.declaracao());
+        } 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(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
+    }
+    declaracaoPara() {
+        const simboloPara = this.avancarEDevolverAnterior();
+        const variavelIteracao = this.consumir(visualg_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
+        this.consumir(visualg_1.default.DE, "Esperado palavra reservada 'de' após variáve de controle de 'para'.");
+        const numeroInicio = this.consumir(visualg_1.default.NUMERO, "Esperado literal ou variável após 'de' em declaração 'para'.");
+        this.consumir(visualg_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
+        const numeroFim = this.consumir(visualg_1.default.NUMERO, "Esperado literal ou variável após 'de' em declaração 'para'.");
+        this.consumir(visualg_1.default.FACA, "Esperado palavra reservada 'faca' 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.declaracao());
+            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));
+        return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), numeroInicio.literal)), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), new lexador_1.Simbolo(visualg_1.default.MENOR, '', '', Number(simboloPara.linha), this.hashArquivo), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), numeroFim.literal)), 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), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1))), corpo);
+    }
+    logicaComumParametros() {
+        const parametros = [];
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.PARENTESE_ESQUERDO)) {
+            while (!this.verificarTipoSimboloAtual(visualg_1.default.PARENTESE_DIREITO)) {
+                const dadosParametros = this.logicaComumParametroVisuAlg();
+                for (let parametro of dadosParametros.identificadores) {
+                    parametros.push({
+                        abrangencia: 'padrao',
+                        nome: parametro
+                    });
+                }
+            }
+            // 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();
+        this.validarSegmentoVar();
+        this.validarSegmentoInicio('procedimento');
+        const corpo = this.blocoEscopo();
+        return new declaracoes_1.FuncaoDeclaracao(nomeProcedimento, new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloProcedimento.linha), parametros, corpo.filter(d => d)));
+    }
+    declaracaoSe() {
+        const simboloSe = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        this.consumir(visualg_1.default.ENTAO, "Esperado palavra reservada 'entao' 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.declaracao());
+        } while (![visualg_1.default.SENAO, visualg_1.default.FIM_SE].includes(this.simbolos[this.atual].tipo));
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(visualg_1.default.SENAO)) {
+            const simboloSenao = this.simbolos[this.atual - 1];
+            const declaracoesSenao = [];
+            do {
+                declaracoesSenao.push(this.declaracao());
+            } 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);
+    }
+    declaracao() {
+        // Refatorar isso no futuro.
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            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.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.SE:
+                return this.declaracaoSe();
+            default:
+                return 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.
+     * - O segundo símbolo é `var`, que pode ser seguido por uma série de
+     * declarações de variáveis e finalizado por uma quebra de linha.
+     * - O terceiro símbolo é `inicio`, seguido por uma quebra de linha.
+     * - 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.hashArquivo = hashArquivo || 0;
+        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
+        let declaracoes = [];
+        this.validarSegmentoAlgoritmo();
+        declaracoes = declaracoes.concat(this.validarSegmentoVar());
+        this.validarSegmentoInicio('algoritmo');
+        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== visualg_1.default.FIM_ALGORITMO) {
+            declaracoes.push(this.declaracao());
+        }
+        return {
+            declaracoes: declaracoes.filter((d) => d),
+            erros: this.erros,
+        };
+    }
+}
+exports.AvaliadorSintaticoVisuAlg = AvaliadorSintaticoVisuAlg;
 //# sourceMappingURL=avaliador-sintatico-visualg.js.map