@designliquido/delegua 0.15.1 → 0.15.3

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

@@ -1,295 +1,320 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvaliadorSintaticoBirl = void 0;
-const construtos_1 = require("../../construtos");
-const declaracoes_1 = require("../../declaracoes");
-const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
-const birl_1 = __importDefault(require("../../tipos-de-simbolos/birl"));
-class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
-    validarSegmentoHoraDoShow() {
-        this.consumir(birl_1.default.HORA, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
-        this.consumir(birl_1.default.DO, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
-        this.consumir(birl_1.default.SHOW, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
-        this.blocos += 1;
-    }
-    validarSegmentoBirlFinal() {
-        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechamento do programa');
-        this.blocos -= 1;
-    }
-    primario() {
-        const simboloAtual = this.simbolos[this.atual];
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.NEGATIVO))
-            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.POSITIVO))
-            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IDENTIFICADOR)) {
-            return new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
-        }
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.NUMERO, birl_1.default.FRANGAO, birl_1.default.FRANGÃO, birl_1.default.FRANGO, birl_1.default.TEXTO)) {
-            const simboloAnterior = this.simbolos[this.atual - 1];
-            return new construtos_1.Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
-        }
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.PARENTESE_ESQUERDO)) {
-            const expressao = this.expressao();
-            this.consumir(birl_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-            return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
-        }
-    }
-    chamar() {
-        return this.primario();
-    }
-    atribuir() {
-        const expressao = this.ou();
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
-            const igual = this.simboloAnterior();
-            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.AcessoMetodo) {
-                const get = expressao;
-                return new construtos_1.DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
-            }
-            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
-                return new construtos_1.AtribuicaoSobrescrita(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
-            }
-            this.erro(igual, 'Tarefa de atribuição inválida');
-        }
-        return expressao;
-    }
-    blocoEscopo() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoEnquanto() {
-        this.consumir(birl_1.default.NEGATIVA, 'Esperado expressão `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
-        this.consumir(birl_1.default.BAMBAM, 'Esperado expressão `BAMBAM` após `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
-        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `BAMBAM` para iniciar o bloco `ENQUANTO`.');
-        const codicao = this.expressao();
-        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição para iniciar o bloco `ENQUANTO`.');
-        const declaracoes = [];
-        while (!this.verificarSeSimboloAtualEIgualA(birl_1.default.BIRL)) {
-            declaracoes.push(this.declaracao());
-        }
-        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `ENQUANTO`.');
-        return new declaracoes_1.Enquanto(codicao, declaracoes);
-    }
-    declaracaoExpressao() {
-        const expressao = this.expressao();
-        this.consumir(birl_1.default.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
-        return new declaracoes_1.Expressao(expressao);
-    }
-    declaracaoPara() {
-        const simboloPara = this.consumir(birl_1.default.MAIS, 'Esperado expressão `MAIS` para iniciar o bloco `PARA`.');
-        this.consumir(birl_1.default.QUERO, 'Esperado expressão `QUERO` após `MAIS` para iniciar o bloco `PARA`.');
-        this.consumir(birl_1.default.MAIS, 'Esperado expressão `MAIS` após `QUERO` para iniciar o bloco `PARA`.');
-        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.');
-        let inicializador;
-        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.PONTO_E_VIRGULA)) {
-            inicializador = null;
-        }
-        else if (this.verificarSeSimboloAtualEIgualA(birl_1.default.MONSTRO)) {
-            inicializador = this.declaracaoDeVariavel();
-        }
-        else {
-            inicializador = this.declaracaoExpressao();
-        }
-        let condicao = null;
-        if (!this.verificarTipoSimboloAtual(birl_1.default.PONTO_E_VIRGULA)) {
-            condicao = this.expressao();
-        }
-        let incrementar = null;
-        if (!this.verificarTipoSimboloAtual(birl_1.default.PARENTESE_DIREITO)) {
-            incrementar = this.expressao();
-        }
-        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição para iniciar o bloco `PARA`.');
-        const declaracao = [];
-        while (!this.verificarSeSimboloAtualEIgualA(birl_1.default.BIRL)) {
-            declaracao.push(this.declaracao());
-        }
-        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `PARA`.');
-        return new declaracoes_1.Para(this.hashArquivo, simboloPara.linha, 0, 0, 0, 0);
-    }
-    declaracaoEscolha() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoEscreva() {
-        const primeiroSimbolo = this.consumir(birl_1.default.CE, 'Esperado expressão `CE` para escrever mensagem.');
-        this.consumir(birl_1.default.QUER, 'Esperado expressão `QUER` após `CE` para escrever mensagem.');
-        this.consumir(birl_1.default.VER, 'Esperado expressão `VER` após `QUER` para escrever mensagem.');
-        this.consumir(birl_1.default.ESSA, 'Esperado expressão `ESSA` após `VER` para escrever mensagem.');
-        this.consumir(birl_1.default.PORRA, 'Esperado expressão `PORRA` após `ESSA` para escrever mensagem.');
-        this.consumir(birl_1.default.INTERROGACAO, 'Esperado interrogação após `PORRA` para escrever mensagem.');
-        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para escrever mensagem.');
-        const argumento = this.declaracao();
-        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após argumento para escrever mensagem.');
-        return new declaracoes_1.Escreva(Number(primeiroSimbolo.linha), this.hashArquivo, [argumento]);
-    }
-    declaracaoFazer() {
-        throw new Error('Método não implementado.');
-    }
-    declaracaoCaracteres() {
-        if (this.verificarTipoSimboloAtual(birl_1.default.BICEPS)) {
-            this.consumir(birl_1.default.BICEPS, '');
-        }
-        const simboloCaractere = this.consumir(birl_1.default.FRANGO, '');
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'FRANGO'.");
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0)));
-            // Inicialização de variáveis que podem ter valor definido;
-            let valorInicializacao;
-            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
-                this.consumir(birl_1.default.TEXTO, "Esperado ' para começar o texto.");
-                const literalInicializacao = this.consumir(birl_1.default.IDENTIFICADOR, 'Esperado literal de FRANGO após símbolo de igual em declaração de variável.');
-                this.consumir(birl_1.default.TEXTO, "Esperado ' para terminar o texto.");
-                valorInicializacao = String(literalInicializacao.literal);
-            }
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao)));
-        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
-        return inicializacoes;
-    }
-    declaracaoInteiros() {
-        let simboloInteiro;
-        if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRO)) {
-            simboloInteiro = this.consumir(birl_1.default.MONSTRO, '');
-        }
-        else if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRINHO)) {
-            simboloInteiro = this.consumir(birl_1.default.MONSTRINHO, '');
-        }
-        else if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRAO)) {
-            simboloInteiro = this.consumir(birl_1.default.MONSTRAO, '');
-        }
-        else {
-            throw new Error('Simbolo referente a inteiro não especificado.');
-        }
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, `Esperado identificador após palavra reservada '${simboloInteiro.lexema}'.`);
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), 0)));
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0x00;
-            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
-                const literalInicializacao = this.consumir(birl_1.default.NUMERO, `Esperado literal de ${simboloInteiro.lexema} após símbolo de igual em declaração de variável.`);
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao)));
-        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
-        return inicializacoes;
-    }
-    declaracaoPontoFlutuante() {
-        const simboloFloat = this.consumir(birl_1.default.TRAPEZIO, '');
-        if (this.verificarTipoSimboloAtual(birl_1.default.DESCENDENTE)) {
-            this.consumir(birl_1.default.DESCENDENTE, '');
-        }
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'TRAPEZIO'.");
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloFloat.linha), 0)));
-            // Inicializações de variáveis que podem ter valores definidos
-            let valorInicializacao = 0x00;
-            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
-                const literalInicializacao = this.consumir(birl_1.default.NUMERO, 'Esperado literal de TRAPEZIO após símbolo de igual em declaração de variavel.');
-                valorInicializacao = parseFloat(literalInicializacao.literal);
-            }
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloFloat.linha), valorInicializacao)));
-        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
-        return inicializacoes;
-    }
-    declaracaoRetorna() {
-        const primeiroSimbolo = this.consumir(birl_1.default.BORA, 'Esperado expressão `BORA` para retornar valor.');
-        this.consumir(birl_1.default.CUMPADE, 'Esperado expressão `CUMPADE` após `BORA` para retornar valor.');
-        // this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `CUMPADE` para retornar valor.');
-        const valor = this.declaracao();
-        return new declaracoes_1.Retorna(primeiroSimbolo, valor);
-    }
-    declaracaoLeia() {
-        const primeiroSimbolo = this.consumir(birl_1.default.QUE, 'Esperado expressão `QUE` para ler valor.');
-        this.consumir(birl_1.default.QUE, 'Esperado expressão `QUE` após `QUE` para ler valor.');
-        this.consumir(birl_1.default.CE, 'Esperado expressão `CE` após `QUE` para ler valor.');
-        this.consumir(birl_1.default.QUER, 'Esperado expressão `QUER` após `CE` para ler valor.');
-        this.consumir(birl_1.default.MONSTRAO, 'Esperado expressão `MONSTRAO` após `QUER` para ler valor.');
-        this.consumir(birl_1.default.INTERROGACAO, 'Esperado interrogação após `MONSTRAO` para ler valor.');
-        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para ler valor.');
-        const simbolo = this.consumir(birl_1.default.TEXTO, 'Esperado texto após parêntese esquerdo para ler valor.');
-        const ponteiro = this.consumir(birl_1.default.IDENTIFICADOR, 'Esperado identificador após texto para ler valor.');
-        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após identificador para ler valor.');
-        this.consumir(birl_1.default.PONTO_E_VIRGULA, 'Esperado ponto e vírgula após parêntese direito para ler valor.');
-        return new declaracoes_1.Leia(Number(primeiroSimbolo.linha), this.hashArquivo, []);
-    }
-    declaracaoSe() {
-        throw new Error('Método não implementado.');
-    }
-    corpoDaFuncao(tipo) {
-        throw new Error('Método não implementado.');
-    }
-    declaracao() {
-        const simboloAtual = this.simbolos[this.atual];
-        switch (simboloAtual.tipo) {
-            case birl_1.default.BORA: // BORA CUMPADE?
-                return this.declaracaoRetorna();
-            case birl_1.default.QUE:
-                return this.declaracaoLeia();
-            case birl_1.default.ELE:
-            // Retornar uma declaração de IF
-            case birl_1.default.NEGATIVA:
-            // Retornar uma declaração de WHILE
-            case birl_1.default.MAIS:
-                return this.declaracaoPara();
-            // Declaração de inteiros
-            case birl_1.default.MONSTRO:
-            case birl_1.default.MONSTRINHO:
-            case birl_1.default.MONSTRAO:
-                return this.declaracaoInteiros();
-            case birl_1.default.BICEPS:
-            case birl_1.default.FRANGO:
-                return this.declaracaoCaracteres();
-            case birl_1.default.TRAPEZIO:
-                return this.declaracaoPontoFlutuante();
-            case birl_1.default.VAMO:
-            // Retornar uma declaração de continue
-            case birl_1.default.SAI:
-            // Retornar uma declaração de break
-            case birl_1.default.OH:
-            // Retornar uma declaração de funcao
-            case birl_1.default.AJUDA:
-            // Retornar uma declaração de chamar funcao
-            case birl_1.default.CE: // "CE QUER VER ESSA PORRA?"
-                return this.declaracaoEscreva();
-            case birl_1.default.PONTO_E_VIRGULA:
-            case birl_1.default.QUEBRA_LINHA:
-                this.avancarEDevolverAnterior();
-                return null;
-            default:
-                return this.expressao();
-        }
-    }
-    analisar(retornoLexador, hashArquivo) {
-        this.erros = [];
-        this.blocos = 0;
-        this.atual = 0;
-        // 1 validação
-        /* if (this.blocos > 0) {
-            throw new ErroAvaliadorSintatico(
-                null,
-                'Quantidade de blocos abertos não corresponde com a quantidade de blocos fechados'
-            );
-        } */
-        this.simbolos = retornoLexador.simbolos;
-        const declaracoes = [];
-        this.validarSegmentoHoraDoShow();
-        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== birl_1.default.BIRL) {
-            declaracoes.push(this.declaracao());
-        }
-        this.validarSegmentoBirlFinal();
-        return {
-            declaracoes: declaracoes.filter((d) => d),
-            erros: this.erros,
-        };
-    }
-}
-exports.AvaliadorSintaticoBirl = AvaliadorSintaticoBirl;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoBirl = void 0;
+const construtos_1 = require("../../construtos");
+const declaracoes_1 = require("../../declaracoes");
+const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
+const birl_1 = __importDefault(require("../../tipos-de-simbolos/birl"));
+class AvaliadorSintaticoBirl extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
+    validarSegmentoHoraDoShow() {
+        this.consumir(birl_1.default.HORA, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
+        this.consumir(birl_1.default.DO, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
+        this.consumir(birl_1.default.SHOW, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
+        this.blocos += 1;
+    }
+    validarSegmentoBirlFinal() {
+        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechamento do programa');
+        this.blocos -= 1;
+    }
+    primario() {
+        const simboloAtual = this.simbolos[this.atual];
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.NEGATIVO))
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.POSITIVO))
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IDENTIFICADOR)) {
+            return new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.NUMERO, birl_1.default.FRANGAO, birl_1.default.FRANGÃO, birl_1.default.FRANGO, birl_1.default.TEXTO)) {
+            const simboloAnterior = this.simbolos[this.atual - 1];
+            return new construtos_1.Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.PARENTESE_ESQUERDO)) {
+            const expressao = this.expressao();
+            this.consumir(birl_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+            return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+        }
+    }
+    chamar() {
+        return this.primario();
+    }
+    atribuir() {
+        const expressao = this.ou();
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
+            const igual = this.simboloAnterior();
+            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.AcessoMetodo) {
+                const get = expressao;
+                return new construtos_1.DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
+            }
+            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                return new construtos_1.AtribuicaoSobrescrita(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
+            }
+            this.erro(igual, 'Tarefa de atribuição inválida');
+        }
+        return expressao;
+    }
+    blocoEscopo() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoEnquanto() {
+        this.consumir(birl_1.default.NEGATIVA, 'Esperado expressão `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
+        this.consumir(birl_1.default.BAMBAM, 'Esperado expressão `BAMBAM` após `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
+        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `BAMBAM` para iniciar o bloco `ENQUANTO`.');
+        const codicao = this.expressao();
+        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição para iniciar o bloco `ENQUANTO`.');
+        const declaracoes = [];
+        while (!this.verificarSeSimboloAtualEIgualA(birl_1.default.BIRL)) {
+            declaracoes.push(this.declaracao());
+        }
+        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `ENQUANTO`.');
+        return new declaracoes_1.Enquanto(codicao, declaracoes);
+    }
+    declaracaoExpressao() {
+        const expressao = this.expressao();
+        this.consumir(birl_1.default.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
+        return new declaracoes_1.Expressao(expressao);
+    }
+    declaracaoPara() {
+        const simboloPara = this.consumir(birl_1.default.MAIS, 'Esperado expressão `MAIS` para iniciar o bloco `PARA`.');
+        this.consumir(birl_1.default.QUERO, 'Esperado expressão `QUERO` após `MAIS` para iniciar o bloco `PARA`.');
+        this.consumir(birl_1.default.MAIS, 'Esperado expressão `MAIS` após `QUERO` para iniciar o bloco `PARA`.');
+        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.');
+        let inicializador;
+        if (this.verificarSeSimboloAtualEIgualA(birl_1.default.PONTO_E_VIRGULA)) {
+            inicializador = null;
+        }
+        else if (this.verificarSeSimboloAtualEIgualA(birl_1.default.MONSTRO)) {
+            inicializador = this.declaracaoDeVariavel();
+        }
+        else {
+            inicializador = this.declaracaoExpressao();
+        }
+        let condicao = null;
+        if (!this.verificarTipoSimboloAtual(birl_1.default.PONTO_E_VIRGULA)) {
+            condicao = this.expressao();
+        }
+        let incrementar = null;
+        if (!this.verificarTipoSimboloAtual(birl_1.default.PARENTESE_DIREITO)) {
+            incrementar = this.expressao();
+        }
+        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição para iniciar o bloco `PARA`.');
+        const declaracao = [];
+        while (!this.verificarSeSimboloAtualEIgualA(birl_1.default.BIRL)) {
+            declaracao.push(this.declaracao());
+        }
+        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `PARA`.');
+        return new declaracoes_1.Para(this.hashArquivo, simboloPara.linha, 0, 0, 0, 0);
+    }
+    declaracaoEscolha() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoEscreva() {
+        const primeiroSimbolo = this.consumir(birl_1.default.CE, 'Esperado expressão `CE` para escrever mensagem.');
+        this.consumir(birl_1.default.QUER, 'Esperado expressão `QUER` após `CE` para escrever mensagem.');
+        this.consumir(birl_1.default.VER, 'Esperado expressão `VER` após `QUER` para escrever mensagem.');
+        this.consumir(birl_1.default.ESSA, 'Esperado expressão `ESSA` após `VER` para escrever mensagem.');
+        this.consumir(birl_1.default.PORRA, 'Esperado expressão `PORRA` após `ESSA` para escrever mensagem.');
+        this.consumir(birl_1.default.INTERROGACAO, 'Esperado interrogação após `PORRA` para escrever mensagem.');
+        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para escrever mensagem.');
+        const argumento = this.declaracao();
+        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após argumento para escrever mensagem.');
+        return new declaracoes_1.Escreva(Number(primeiroSimbolo.linha), this.hashArquivo, [argumento]);
+    }
+    declaracaoFazer() {
+        throw new Error('Método não implementado.');
+    }
+    declaracaoCaracteres() {
+        if (this.verificarTipoSimboloAtual(birl_1.default.BICEPS)) {
+            this.consumir(birl_1.default.BICEPS, '');
+        }
+        const simboloCaractere = this.consumir(birl_1.default.FRANGO, '');
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'FRANGO'.");
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0)));
+            // Inicialização de variáveis que podem ter valor definido;
+            let valorInicializacao;
+            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
+                this.consumir(birl_1.default.TEXTO, "Esperado ' para começar o texto.");
+                const literalInicializacao = this.consumir(birl_1.default.IDENTIFICADOR, 'Esperado literal de FRANGO após símbolo de igual em declaração de variável.');
+                this.consumir(birl_1.default.TEXTO, "Esperado ' para terminar o texto.");
+                valorInicializacao = String(literalInicializacao.literal);
+            }
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao)));
+        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
+        return inicializacoes;
+    }
+    declaracaoInteiros() {
+        let simboloInteiro;
+        if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRO)) {
+            simboloInteiro = this.consumir(birl_1.default.MONSTRO, '');
+        }
+        else if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRINHO)) {
+            simboloInteiro = this.consumir(birl_1.default.MONSTRINHO, '');
+        }
+        else if (this.verificarTipoSimboloAtual(birl_1.default.MONSTRAO)) {
+            simboloInteiro = this.consumir(birl_1.default.MONSTRAO, '');
+        }
+        else {
+            throw new Error('Simbolo referente a inteiro não especificado.');
+        }
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, `Esperado identificador após palavra reservada '${simboloInteiro.lexema}'.`);
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), 0)));
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0x00;
+            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
+                const literalInicializacao = this.consumir(birl_1.default.NUMERO, `Esperado literal de ${simboloInteiro.lexema} após símbolo de igual em declaração de variável.`);
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao)));
+        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
+        return inicializacoes;
+    }
+    declaracaoPontoFlutuante() {
+        const simboloFloat = this.consumir(birl_1.default.TRAPEZIO, '');
+        if (this.verificarTipoSimboloAtual(birl_1.default.DESCENDENTE)) {
+            this.consumir(birl_1.default.DESCENDENTE, '');
+        }
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(birl_1.default.IDENTIFICADOR, "Esperado identificador após palavra reservada 'TRAPEZIO'.");
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloFloat.linha), 0)));
+            // Inicializações de variáveis que podem ter valores definidos
+            let valorInicializacao = 0x00;
+            if (this.verificarSeSimboloAtualEIgualA(birl_1.default.IGUAL)) {
+                const literalInicializacao = this.consumir(birl_1.default.NUMERO, 'Esperado literal de TRAPEZIO após símbolo de igual em declaração de variavel.');
+                valorInicializacao = parseFloat(literalInicializacao.literal);
+            }
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloFloat.linha), valorInicializacao)));
+        } while (this.verificarSeSimboloAtualEIgualA(birl_1.default.VIRGULA));
+        return inicializacoes;
+    }
+    declaracaoRetorna() {
+        const primeiroSimbolo = this.consumir(birl_1.default.BORA, 'Esperado expressão `BORA` para retornar valor.');
+        this.consumir(birl_1.default.CUMPADE, 'Esperado expressão `CUMPADE` após `BORA` para retornar valor.');
+        // this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `CUMPADE` para retornar valor.');
+        const valor = this.declaracao();
+        return new declaracoes_1.Retorna(primeiroSimbolo, valor);
+    }
+    declaracaoLeia() {
+        const primeiroSimbolo = this.consumir(birl_1.default.QUE, 'Esperado expressão `QUE` para ler valor.');
+        this.consumir(birl_1.default.QUE, 'Esperado expressão `QUE` após `QUE` para ler valor.');
+        this.consumir(birl_1.default.CE, 'Esperado expressão `CE` após `QUE` para ler valor.');
+        this.consumir(birl_1.default.QUER, 'Esperado expressão `QUER` após `CE` para ler valor.');
+        this.consumir(birl_1.default.MONSTRAO, 'Esperado expressão `MONSTRAO` após `QUER` para ler valor.');
+        this.consumir(birl_1.default.INTERROGACAO, 'Esperado interrogação após `MONSTRAO` para ler valor.');
+        this.consumir(birl_1.default.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para ler valor.');
+        const simbolo = this.consumir(birl_1.default.TEXTO, 'Esperado texto após parêntese esquerdo para ler valor.');
+        const ponteiro = this.consumir(birl_1.default.IDENTIFICADOR, 'Esperado identificador após texto para ler valor.');
+        this.consumir(birl_1.default.PARENTESE_DIREITO, 'Esperado parêntese direito após identificador para ler valor.');
+        this.consumir(birl_1.default.PONTO_E_VIRGULA, 'Esperado ponto e vírgula após parêntese direito para ler valor.');
+        return new declaracoes_1.Leia(Number(primeiroSimbolo.linha), this.hashArquivo, []);
+    }
+    declaracaoSe() {
+        const simboloSe = this.consumir(birl_1.default.ELE, 'Esperado expressão `ELE` para condição.');
+        this.consumir(birl_1.default.QUE, 'Esperado expressão `QUE` após `ELE` para condição.');
+        this.consumir(birl_1.default.A, 'Esperado expressão `A` após `QUE` para condição.');
+        this.consumir(birl_1.default.GENTE, 'Esperado expressão `GENTE` após `A` para condição.');
+        this.consumir(birl_1.default.QUER, 'Esperado expressão `QUER` após `GENTE` para condição.');
+        this.consumir(birl_1.default.INTERROGACAO, 'Esperado interrogação após `QUER` para condição.');
+        const condicao = this.declaracao();
+        this.consumir(birl_1.default.QUEBRA_LINHA, 'Esperado quebra de linha após expressão de condição para condição.');
+        const declaracoes = [];
+        while (this.verificarTipoSimboloAtual(birl_1.default.QUEBRA_LINHA)) {
+            this.consumir(birl_1.default.QUEBRA_LINHA, '');
+        }
+        do {
+            declaracoes.push(this.declaracao());
+            this.avancarEDevolverAnterior();
+        } while (![birl_1.default.BIRL].includes(this.simbolos[this.atual].tipo));
+        let caminhoSenao = null;
+        if (this.verificarTipoSimboloAtual(birl_1.default.NAO)) {
+            const simboloSenao = this.consumir(birl_1.default.NAO, 'Esperado expressão `NAO` após expressão de condição.');
+            this.consumir(birl_1.default.VAI, 'Esperado expressão `VAI` após `NAO`.');
+            this.consumir(birl_1.default.DAR, 'Esperado expressão `DAR` após `VAI`.');
+            this.consumir(birl_1.default.NAO, 'Esperado expressão `NAO` após `DAR`.');
+            const declaracaoSenao = [];
+            do {
+                declaracaoSenao.push(this.declaracao());
+            } while (![birl_1.default.BIRL].includes(this.simbolos[this.atual].tipo));
+            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracaoSenao.filter((d) => d));
+        }
+        this.consumir(birl_1.default.BIRL, 'Esperado expressão `BIRL` após expressão de condição.');
+        return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
+    }
+    corpoDaFuncao(tipo) {
+        throw new Error('Método não implementado.');
+    }
+    declaracao() {
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            case birl_1.default.BORA: // BORA CUMPADE?
+                return this.declaracaoRetorna();
+            case birl_1.default.QUE:
+                return this.declaracaoLeia();
+            case birl_1.default.ELE:
+                return this.declaracaoSe();
+            case birl_1.default.NEGATIVA:
+            // Retornar uma declaração de WHILE
+            case birl_1.default.MAIS:
+                return this.declaracaoPara();
+            // Declaração de inteiros
+            case birl_1.default.MONSTRO:
+            case birl_1.default.MONSTRINHO:
+            case birl_1.default.MONSTRAO:
+                return this.declaracaoInteiros();
+            case birl_1.default.BICEPS:
+            case birl_1.default.FRANGO:
+                return this.declaracaoCaracteres();
+            case birl_1.default.TRAPEZIO:
+                return this.declaracaoPontoFlutuante();
+            case birl_1.default.OH:
+            // Retornar uma declaração de funcao
+            case birl_1.default.AJUDA:
+            // Retornar uma declaração de chamar funcao
+            case birl_1.default.CE: // "CE QUER VER ESSA PORRA?"
+                return this.declaracaoEscreva();
+            case birl_1.default.PONTO_E_VIRGULA:
+            case birl_1.default.QUEBRA_LINHA:
+                this.avancarEDevolverAnterior();
+                return null;
+            default:
+                return this.expressao();
+        }
+    }
+    analisar(retornoLexador, hashArquivo) {
+        this.erros = [];
+        this.blocos = 0;
+        this.atual = 0;
+        // 1 validação
+        /* if (this.blocos > 0) {
+            throw new ErroAvaliadorSintatico(
+                null,
+                'Quantidade de blocos abertos não corresponde com a quantidade de blocos fechados'
+            );
+        } */
+        this.simbolos = retornoLexador.simbolos;
+        const declaracoes = [];
+        this.validarSegmentoHoraDoShow();
+        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== birl_1.default.BIRL) {
+            declaracoes.push(this.declaracao());
+        }
+        this.validarSegmentoBirlFinal();
+        return {
+            declaracoes: declaracoes.filter((d) => d),
+            erros: this.erros,
+        };
+    }
+}
+exports.AvaliadorSintaticoBirl = AvaliadorSintaticoBirl;
 //# sourceMappingURL=avaliador-sintatico-birl.js.map