@designliquido/delegua 0.61.1 → 0.61.3

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

@@ -0,0 +1,714 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoPrisma = void 0;
+const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const construtos_1 = require("../../construtos");
+const declaracoes_1 = require("../../declaracoes");
+const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
+const erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
+const inferenciador_1 = require("../../inferenciador");
+const pilha_escopos_1 = require("../pilha-escopos");
+const informacao_escopo_1 = require("../informacao-escopo");
+const comum_1 = require("../comum");
+const informacao_elemento_sintatico_1 = require("../../informacao-elemento-sintatico");
+const lexador_1 = require("../../lexador");
+const prisma_1 = __importDefault(require("../../tipos-de-simbolos/prisma"));
+const primitivas_dicionario_1 = __importDefault(require("../../bibliotecas/primitivas-dicionario"));
+const primitivas_numero_1 = __importDefault(require("../../bibliotecas/primitivas-numero"));
+const primitivas_texto_1 = __importDefault(require("../../bibliotecas/primitivas-texto"));
+const primitivas_vetor_1 = __importDefault(require("../../bibliotecas/primitivas-vetor"));
+/**
+ * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
+ * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
+ * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
+ *
+ * Este avaliador sintático é específico para o dialeto Prisma da linguagem Delégua.
+ */
+class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
+    constructor(performance = false) {
+        super();
+        this.atual = 0;
+        this.blocos = 0;
+        this.performance = performance;
+        this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
+        this.primitivasConhecidas = {};
+        this.tiposDefinidosEmCodigo = {};
+        (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'dicionário', primitivas_dicionario_1.default);
+        (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'número', primitivas_numero_1.default);
+        (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'texto', primitivas_texto_1.default);
+        (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'vetor', primitivas_vetor_1.default);
+    }
+    sincronizar() {
+        this.avancarEDevolverAnterior();
+        while (!this.estaNoFinal()) {
+            switch (this.simboloAtual().tipo) {
+                case prisma_1.default.CLASSE:
+                case prisma_1.default.FUNCAO:
+                case prisma_1.default.FUNÇÃO:
+                case prisma_1.default.LOCAL:
+                case prisma_1.default.PARA:
+                case prisma_1.default.SE:
+                case prisma_1.default.ENQUANTO:
+                case prisma_1.default.IMPRIMA:
+                case prisma_1.default.RETORNE:
+                    return;
+            }
+            this.avancarEDevolverAnterior();
+        }
+    }
+    erro(simbolo, mensagemDeErro) {
+        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        this.erros.push(excecao);
+        return excecao;
+    }
+    consumir(tipo, mensagemDeErro) {
+        if (this.verificarTipoSimboloAtual(tipo))
+            return this.avancarEDevolverAnterior();
+        let simboloErro = this.simbolos[this.atual];
+        if (this.simbolos.length === 0) {
+            simboloErro = {
+                hashArquivo: this.hashArquivo,
+                linha: 1,
+            };
+        }
+        else if (this.atual >= this.simbolos.length) {
+            simboloErro = this.simbolos[this.simbolos.length - 1];
+        }
+        throw this.erro(simboloErro, mensagemDeErro);
+    }
+    verificarTipoSimboloAtual(tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simboloAtual().tipo === tipo;
+    }
+    verificarTipoProximoSimbolo(tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simbolos[this.atual + 1].tipo === tipo;
+    }
+    simboloAtual() {
+        return this.simbolos[this.atual];
+    }
+    simboloAnterior() {
+        return this.simbolos[this.atual - 1];
+    }
+    simboloNaPosicao(posicao) {
+        return this.simbolos[this.atual + posicao];
+    }
+    estaNoFinal() {
+        return this.atual >= this.simbolos.length;
+    }
+    avancarEDevolverAnterior() {
+        if (!this.estaNoFinal())
+            this.atual += 1;
+        return this.simboloAnterior();
+    }
+    verificarSeSimboloAtualEIgualA(...argumentos) {
+        for (let i = 0; i < argumentos.length; i++) {
+            const tipoAtual = argumentos[i];
+            if (this.verificarTipoSimboloAtual(tipoAtual)) {
+                this.avancarEDevolverAnterior();
+                return true;
+            }
+        }
+        return false;
+    }
+    primario() {
+        const simboloAtual = this.simbolos[this.atual];
+        let valores = [];
+        switch (simboloAtual.tipo) {
+            case prisma_1.default.COLCHETE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                switch (this.simboloAtual().tipo) {
+                    case prisma_1.default.COLCHETE_ESQUERDO: // Texto multilinhas
+                        return this.construtoTextoMultilinhas();
+                    default:
+                        throw this.erro(simboloAtual, 'Terminar.');
+                }
+            case prisma_1.default.CHAVE_ESQUERDA:
+                // Prisma tem o conceito de tabela, que não é exatamente um dicionário, mas é próximo.
+                // Aqui, vamos tratar como dicionário para simplificar.
+                this.avancarEDevolverAnterior();
+                const chaves = [];
+                if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CHAVE_DIREITA)) {
+                    return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, [], []);
+                }
+                let indice = 1;
+                do {
+                    let chave = String(indice);
+                    if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_ESQUERDO)) {
+                        // Lógica para índice nomeado
+                        // TODO: Terminar
+                    }
+                    const valor = this.ou();
+                    chaves.push(chave);
+                    valores.push(valor);
+                    indice++;
+                } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
+                this.consumir(prisma_1.default.CHAVE_DIREITA, `Esperado fechamento de chave em tabela.`);
+                return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, chaves, valores);
+            case prisma_1.default.FALSO:
+            case prisma_1.default.VERDADEIRO:
+                const simboloLogico = this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, simboloLogico.tipo === prisma_1.default.VERDADEIRO, 'lógico');
+            case prisma_1.default.FUNCAO:
+            case prisma_1.default.FUNÇÃO:
+                const simboloFuncao = this.avancarEDevolverAnterior();
+                const corpoDaFuncao = this.corpoDaFuncao(simboloFuncao.lexema);
+                this.pilhaEscopos.definirInformacoesVariavel(simboloFuncao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloFuncao.lexema, 'função'));
+                return corpoDaFuncao;
+            case prisma_1.default.IMPORTAR:
+                return this.expressaoImportar();
+            case prisma_1.default.NULO:
+                this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, null);
+            case prisma_1.default.ISTO:
+                const simboloIsto = this.avancarEDevolverAnterior();
+                return new construtos_1.Isto(this.hashArquivo, simboloAtual.linha, simboloIsto);
+            case prisma_1.default.LEIA:
+                return this.expressaoLeia();
+            case prisma_1.default.NUMERO:
+            case prisma_1.default.TEXTO:
+                const simboloLiteral = this.avancarEDevolverAnterior();
+                const tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(simboloLiteral.literal);
+                const tipoDadosElementar = (0, inferenciador_1.tipoInferenciaParaTipoDadosElementar)(tipoInferido);
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal, tipoDadosElementar);
+            case prisma_1.default.IDENTIFICADOR:
+                const simboloIdentificador = this.avancarEDevolverAnterior();
+                let tipoOperando;
+                if (simboloIdentificador.lexema in this.tiposDefinidosEmCodigo) {
+                    tipoOperando = simboloIdentificador.lexema;
+                }
+                else {
+                    try {
+                        tipoOperando = this.pilhaEscopos.obterTipoVariavelPorNome(simboloIdentificador.lexema);
+                    }
+                    catch (erro) {
+                        throw this.erro(simboloIdentificador, erro.message);
+                    }
+                }
+                return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando);
+            case prisma_1.default.PARENTESE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                const expressao = this.expressao();
+                this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                return new construtos_1.Agrupamento(this.hashArquivo, simboloAtual.linha, expressao);
+            case prisma_1.default.SUPER:
+                const simboloSuper = this.avancarEDevolverAnterior();
+                return new construtos_1.Super(this.hashArquivo, simboloSuper, this.superclasseAtual);
+        }
+        throw this.erro(this.simboloAtual(), 'Esperado expressão.');
+    }
+    expressaoImportar() {
+        throw new Error('Método não implementado.');
+    }
+    /**
+     * Construto para texto multilinhas.
+     * @returns
+     */
+    construtoTextoMultilinhas() {
+        const segundoColchete = this.consumir(prisma_1.default.COLCHETE_ESQUERDO, "Esperado '[' antes do texto multilinhas.");
+        let texto = "";
+        let linha = segundoColchete.linha;
+        while (!this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_DIREITO)) {
+            texto += this.simbolos[this.atual].lexema + " ";
+            if (this.simbolos[this.atual].linha !== linha) {
+                texto += "\n";
+                linha = this.simbolos[this.atual].linha;
+            }
+            this.avancarEDevolverAnterior();
+        }
+        this.consumir(prisma_1.default.COLCHETE_DIREITO, "Esperado ']' após o texto multilinhas.");
+        return new construtos_1.Literal(this.hashArquivo, segundoColchete.linha, texto);
+    }
+    expressaoLeia() {
+        const simboloLeia = this.avancarEDevolverAnterior();
+        this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
+        const argumentos = [];
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
+            do {
+                argumentos.push(this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
+        }
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
+        return new construtos_1.Leia(simboloLeia, argumentos);
+    }
+    finalizarChamada(entidadeChamada) {
+        const argumentos = [];
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
+            do {
+                if (argumentos.length >= 255) {
+                    throw this.erro(this.simboloAtual(), 'Não pode haver mais de 255 argumentos.');
+                }
+                argumentos.push(this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
+        }
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, argumentos);
+    }
+    chamar() {
+        let expressao = this.primario();
+        while (true) {
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PARENTESE_ESQUERDO)) {
+                expressao = this.finalizarChamada(expressao);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PONTO)) {
+                const nome = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_ESQUERDO)) {
+                const indice = this.expressao();
+                const simboloFechamento = this.consumir(prisma_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
+            }
+            else {
+                break;
+            }
+        }
+        return expressao;
+    }
+    unario() {
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.NEGACAO, prisma_1.default.SUBTRACAO, prisma_1.default.BIT_NOT)) {
+            const operador = this.simboloAnterior();
+            const direito = this.unario();
+            return new construtos_1.Unario(this.hashArquivo, operador, direito);
+        }
+        return this.chamar();
+    }
+    exponenciacao() {
+        let expressao = this.unario();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.EXPONENCIACAO)) {
+            const operador = this.simboloAnterior();
+            const direito = this.unario();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    multiplicar() {
+        let expressao = this.exponenciacao();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.DIVISAO, prisma_1.default.DIVISAO_INTEIRA, prisma_1.default.MULTIPLICACAO, prisma_1.default.MODULO)) {
+            const operador = this.simboloAnterior();
+            const direito = this.exponenciacao();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    adicaoOuSubtracao() {
+        let expressao = this.multiplicar();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SUBTRACAO, prisma_1.default.ADICAO)) {
+            const operador = this.simboloAnterior();
+            const direito = this.multiplicar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    bitShift() {
+        let expressao = this.adicaoOuSubtracao();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.MENOR_MENOR, prisma_1.default.MAIOR_MAIOR)) {
+            const operador = this.simboloAnterior();
+            const direito = this.adicaoOuSubtracao();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    bitE() {
+        let expressao = this.bitShift();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.BIT_AND)) {
+            const operador = this.simboloAnterior();
+            const direito = this.bitShift();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    bitOu() {
+        let expressao = this.bitE();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.BIT_OR, prisma_1.default.BIT_XOR)) {
+            const operador = this.simboloAnterior();
+            const direito = this.bitE();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    comparar() {
+        let expressao = this.bitOu();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.MAIOR, prisma_1.default.MAIOR_IGUAL, prisma_1.default.MENOR, prisma_1.default.MENOR_IGUAL)) {
+            const operador = this.simboloAnterior();
+            const direito = this.bitOu();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.DIFERENTE, prisma_1.default.IGUAL_IGUAL)) {
+            const operador = this.simboloAnterior();
+            const direito = this.comparar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    em() {
+        let expressao = this.comparacaoIgualdade();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.EM)) {
+            const operador = this.simboloAnterior();
+            const direito = this.comparacaoIgualdade();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    e() {
+        let expressao = this.em();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.E)) {
+            const operador = this.simboloAnterior();
+            const direito = this.em();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    ou() {
+        let expressao = this.e();
+        while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.OU)) {
+            const operador = this.simboloAnterior();
+            const direito = this.e();
+            expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    atribuir() {
+        const expressao = this.ou();
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL) ||
+            this.verificarSeSimboloAtualEIgualA(prisma_1.default.MAIS_IGUAL)) {
+            const igual = this.simboloAnterior();
+            const valor = this.atribuir();
+            if (expressao instanceof construtos_1.Variavel) {
+                return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
+            }
+            if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
+                return new construtos_1.DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
+            }
+            if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
+            }
+            throw this.erro(igual, 'Tarefa de atribuição inválida');
+        }
+        return expressao;
+    }
+    expressao() {
+        return this.atribuir();
+    }
+    declaracaoEscreva() {
+        const simboloEscreva = this.simboloAnterior();
+        this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em imprima.");
+        const argumentos = [];
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
+            do {
+                argumentos.push(this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
+        }
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em imprima.");
+        this.verificarSeSimboloAtualEIgualA(prisma_1.default.PONTO_E_VIRGULA);
+        return new declaracoes_1.Escreva(Number(simboloEscreva.linha), simboloEscreva.hashArquivo, argumentos);
+    }
+    declaracaoExpressao() {
+        const expressao = this.expressao();
+        return new declaracoes_1.Expressao(expressao);
+    }
+    blocoEscopo() {
+        this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
+        let declaracoes = [];
+        while (!this.verificarTipoSimboloAtual(prisma_1.default.FIM) && !this.estaNoFinal()) {
+            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(retornoDeclaracao)) {
+                declaracoes = declaracoes.concat(retornoDeclaracao);
+            }
+            else {
+                declaracoes.push(retornoDeclaracao);
+            }
+        }
+        this.consumir(prisma_1.default.FIM, "Esperado 'fim' após o bloco.");
+        this.pilhaEscopos.removerUltimo();
+        return declaracoes;
+    }
+    declaracaoDeLocal() {
+        const identificador = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
+        let inicializador = null;
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL)) {
+            inicializador = this.expressao();
+        }
+        this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após declaração de variável.");
+        // Para Prisma, mantemos a tipagem inferida de forma simples por enquanto.
+        const tipo = 'qualquer';
+        this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
+        return new declaracoes_1.Var(identificador, inicializador, tipo);
+    }
+    declaracaoEnquanto() {
+        try {
+            this.blocos += 1;
+            const condicao = this.expressao();
+            const bloco = this.resolverDeclaracao();
+            return new declaracoes_1.Enquanto(condicao, bloco);
+        }
+        finally {
+            this.blocos -= 1;
+        }
+    }
+    declaracaoSe() {
+        const simboloSe = this.simbolos[this.atual];
+        const condicao = this.expressao();
+        this.consumir(prisma_1.default.ENTAO, "Esperado palavra reservada 'entao' ou 'então' após condição em declaração 'se'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (!this.estaNoFinal() &&
+            ![prisma_1.default.SENAO, prisma_1.default.SENÃO, prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SENAO, prisma_1.default.SENÃO)) {
+            const simboloSenao = this.simbolos[this.atual - 1];
+            const declaracoesSenao = [];
+            do {
+                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
+            } while (![prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
+        }
+        this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fimse' para fechamento de declaração 'se'.");
+        return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
+    }
+    declaracaoQuebre() {
+        if (this.blocos < 1) {
+            throw this.erro(this.simboloAnterior(), "'quebre' deve estar dentro de um laço de repetição.");
+        }
+        this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'quebre'.");
+        return new declaracoes_1.Sustar(this.simboloAtual());
+    }
+    declaracaoContinua() {
+        if (this.blocos < 1) {
+            throw this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
+        }
+        this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
+        return new declaracoes_1.Continua(this.simboloAtual());
+    }
+    declaracaoRetorna() {
+        const palavraChave = this.simboloAnterior();
+        let valor = null;
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PONTO_E_VIRGULA)) {
+            valor = this.expressao();
+        }
+        this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após valor de retorno.");
+        return new declaracoes_1.Retorna(palavraChave, valor);
+    }
+    declaracaoImportar() {
+        this.avancarEDevolverAnterior();
+        this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        const caminho = this.expressao();
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        return new declaracoes_1.Importar(caminho);
+    }
+    corpoDaFuncao(tipo) {
+        const parenteseEsquerdo = this.consumir(prisma_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
+        let parametros = [];
+        if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
+            parametros = this.logicaComumParametros();
+        }
+        this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        let tipoRetorno = 'qualquer';
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SETA)) {
+            tipoRetorno = 'qualquer'; // Simplificado por enquanto
+        }
+        const corpo = this.blocoEscopo();
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo, tipoRetorno, false);
+    }
+    logicaComumParametros() {
+        const parametros = [];
+        do {
+            if (parametros.length >= 255) {
+                throw this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
+            }
+            const parametro = {};
+            parametro.abrangencia = 'padrao';
+            parametro.nome = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            }
+            this.pilhaEscopos.definirInformacoesVariavel(parametro.nome.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer'));
+            parametros.push(parametro);
+        } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
+        return parametros;
+    }
+    funcao(tipo) {
+        const simbolo = this.consumir(prisma_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+        this.pilhaEscopos.definirInformacoesVariavel(simbolo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simbolo.lexema, 'qualquer'));
+        const corpoDaFuncao = this.corpoDaFuncao(tipo);
+        const tipoDaFuncao = `função<${corpoDaFuncao.tipo}>`;
+        this.pilhaEscopos.definirInformacoesVariavel(simbolo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simbolo.lexema, tipoDaFuncao));
+        const funcaoDeclaracao = new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, tipoDaFuncao);
+        this.pilhaEscopos.registrarReferenciaFuncao(simbolo.lexema, funcaoDeclaracao);
+        return funcaoDeclaracao;
+    }
+    resolverDeclaracao() {
+        switch (this.simbolos[this.atual].tipo) {
+            case prisma_1.default.CONTINUA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoContinua();
+            case prisma_1.default.PONTO_E_VIRGULA:
+                // Ignora ponto e vírgula supérfluo
+                this.avancarEDevolverAnterior();
+                return null;
+            case prisma_1.default.ENTAO:
+            case prisma_1.default.INICIO:
+                const simboloInicioBloco = this.avancarEDevolverAnterior();
+                return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
+            case prisma_1.default.ENQUANTO:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEnquanto();
+            case prisma_1.default.IMPRIMA:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoEscreva();
+            case prisma_1.default.PARA:
+                return this.declaracaoPara();
+            case prisma_1.default.QUEBRE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoQuebre();
+            case prisma_1.default.SE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoSe();
+            case prisma_1.default.RETORNE:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoRetorna();
+            case prisma_1.default.LOCAL:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoDeLocal();
+        }
+        return this.declaracaoExpressao();
+    }
+    declaracaoPara() {
+        try {
+            this.blocos += 1;
+            const simboloPara = this.avancarEDevolverAnterior();
+            const variavelIteracao = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
+            this.consumir(prisma_1.default.IGUAL, `'=' or 'em' esperado próximo a '${this.simbolos[this.atual].lexema}'.`);
+            const literalOuVariavelInicio = this.adicaoOuSubtracao();
+            this.consumir(prisma_1.default.VIRGULA, `Espera-se '=' próximo a '${this.simbolos[this.atual].lexema}'.`);
+            const literalOuVariavelFim = this.adicaoOuSubtracao();
+            let operadorCondicao = new lexador_1.Simbolo(prisma_1.default.MENOR_IGUAL, '<=', null, Number(simboloPara.linha), this.hashArquivo);
+            let operadorCondicaoIncremento = new lexador_1.Simbolo(prisma_1.default.MENOR, '<', null, Number(simboloPara.linha), this.hashArquivo);
+            let passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
+            const resolverIncrementoEmExecucao = false; // Mudar caso seja necessário.
+            this.consumir(prisma_1.default.INICIO, `espera-se 'inicio' proximo a '${this.simbolos[this.atual].lexema}'.`);
+            // Aqui já é seguro inicializar a variável.
+            this.pilhaEscopos.definirInformacoesVariavel(variavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelIteracao.lexema, 'inteiro'));
+            const declaracoesBlocoPara = [];
+            let simboloAtualBlocoPara = this.simbolos[this.atual];
+            while (simboloAtualBlocoPara.tipo !== prisma_1.default.FIM) {
+                declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
+                simboloAtualBlocoPara = this.simbolos[this.atual];
+            }
+            this.avancarEDevolverAnterior(); // fim
+            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 declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), literalOuVariavelInicio)), 
+            // Condição.
+            new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), 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, 'inteiro'), operadorCondicaoIncremento, literalOuVariavelFim), new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao, 'inteiro'), new lexador_1.Simbolo(prisma_1.default.ADICAO, '+', null, Number(simboloPara.linha), this.hashArquivo), passo)))), corpo);
+            para.blocoPosExecucao = corpo;
+            para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
+            return para;
+        }
+        finally {
+            this.blocos -= 1;
+        }
+    }
+    resolverDeclaracaoForaDeBloco() {
+        try {
+            if ((this.verificarTipoSimboloAtual(prisma_1.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(prisma_1.default.FUNÇÃO)) &&
+                this.verificarTipoProximoSimbolo(prisma_1.default.IDENTIFICADOR)) {
+                this.avancarEDevolverAnterior();
+                return this.funcao('funcao');
+            }
+            if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CLASSE))
+                return this.declaracaoDeClasse();
+            return this.resolverDeclaracao();
+        }
+        catch (erro) {
+            this.sincronizar();
+            return null;
+        }
+    }
+    declaracaoDeClasse() {
+        const simbolo = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        let superClasse = null;
+        if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PARENTESE_ESQUERDO)) {
+            const simboloSuperclasse = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            this.superclasseAtual = simboloSuperclasse.lexema;
+            superClasse = new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
+            this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        }
+        this.consumir(prisma_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
+        const metodos = [];
+        while (!this.estaNoFinal() &&
+            (this.verificarTipoSimboloAtual(prisma_1.default.CONSTRUTOR) ||
+                this.verificarTipoSimboloAtual(prisma_1.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(prisma_1.default.FUNÇÃO))) {
+            const ehConstrutor = this.verificarSeSimboloAtualEIgualA(prisma_1.default.CONSTRUTOR);
+            metodos.push(this.funcao('método'));
+        }
+        this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após métodos da classe.");
+        this.superclasseAtual = undefined;
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos);
+        this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
+        return definicaoClasse;
+    }
+    inicializarPilhaEscopos() {
+        this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
+        this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
+        // Funções nativas básicas
+        this.pilhaEscopos.definirInformacoesVariavel('aleatorio', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('aleatorio', 'número'));
+        this.pilhaEscopos.definirInformacoesVariavel('inteiro', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('inteiro', 'inteiro', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valor', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('numero', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('número', 'número', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('texto', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('texto', 'texto', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
+        ]));
+        this.pilhaEscopos.definirInformacoesVariavel('tamanho', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tamanho', 'inteiro', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('objeto', 'qualquer'),
+        ]));
+    }
+    analisar(retornoLexador, hashArquivo) {
+        const inicioAnalise = (0, browser_process_hrtime_1.default)();
+        this.erros = [];
+        this.atual = 0;
+        this.blocos = 0;
+        this.inicializarPilhaEscopos();
+        this.tiposDefinidosEmCodigo = {};
+        this.hashArquivo = hashArquivo || 0;
+        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
+        let declaracoes = [];
+        while (!this.estaNoFinal()) {
+            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(retornoDeclaracao)) {
+                declaracoes = declaracoes.concat(retornoDeclaracao);
+            }
+            else if (retornoDeclaracao !== null) {
+                declaracoes.push(retornoDeclaracao);
+            }
+        }
+        if (this.performance) {
+            const deltaAnalise = (0, browser_process_hrtime_1.default)(inicioAnalise);
+            console.log(`[Avaliador Sintático] Tempo para análise: ${deltaAnalise[0] * 1e9 + deltaAnalise[1]}ns`);
+        }
+        return {
+            declaracoes: declaracoes,
+            erros: this.erros,
+        };
+    }
+}
+exports.AvaliadorSintaticoPrisma = AvaliadorSintaticoPrisma;
+//# sourceMappingURL=avaliador-sintatico-prisma.js.map