@designliquido/delegua 0.2.1 → 0.2.4

package/fontes/avaliador-sintatico/dialetos/egua-classico.js

@@ -0,0 +1,646 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoEguaClassico = void 0;
+var tipos_de_simbolos_1 = __importDefault(require("../../tipos-de-simbolos"));
+var construtos_1 = require("../../construtos");
+var erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
+var declaracoes_1 = require("../../declaracoes");
+/**
+ * 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.
+ */
+var AvaliadorSintaticoEguaClassico = /** @class */ (function () {
+    function AvaliadorSintaticoEguaClassico(simbolos) {
+        this.simbolos = simbolos;
+        this.atual = 0;
+        this.ciclos = 0;
+    }
+    AvaliadorSintaticoEguaClassico.prototype.sincronizar = function () {
+        this.avancarEDevolverAnterior();
+        while (!this.estaNoFinal()) {
+            if (this.simboloAnterior().tipo === tipos_de_simbolos_1.default.PONTO_E_VIRGULA)
+                return;
+            switch (this.simboloAtual().tipo) {
+                case tipos_de_simbolos_1.default.CLASSE:
+                case tipos_de_simbolos_1.default.FUNÇÃO:
+                case tipos_de_simbolos_1.default.VARIAVEL:
+                case tipos_de_simbolos_1.default.PARA:
+                case tipos_de_simbolos_1.default.SE:
+                case tipos_de_simbolos_1.default.ENQUANTO:
+                case tipos_de_simbolos_1.default.ESCREVA:
+                case tipos_de_simbolos_1.default.RETORNA:
+                    return;
+            }
+            this.avancarEDevolverAnterior();
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.erro = function (simbolo, mensagemDeErro) {
+        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        this.erros.push(excecao);
+        return excecao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.consumir = function (tipo, mensagemDeErro) {
+        if (this.verificarTipoSimboloAtual(tipo))
+            return this.avancarEDevolverAnterior();
+        else
+            throw this.erro(this.simboloAtual(), mensagemDeErro);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.verificarTipoSimboloAtual = function (tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simboloAtual().tipo === tipo;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.verificarTipoProximoSimbolo = function (tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simbolos[this.atual + 1].tipo === tipo;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.simboloAtual = function () {
+        return this.simbolos[this.atual];
+    };
+    AvaliadorSintaticoEguaClassico.prototype.simboloAnterior = function () {
+        return this.simbolos[this.atual - 1];
+    };
+    AvaliadorSintaticoEguaClassico.prototype.simboloNaPosicao = function (posicao) {
+        return this.simbolos[this.atual + posicao];
+    };
+    AvaliadorSintaticoEguaClassico.prototype.estaNoFinal = function () {
+        return this.simboloAtual().tipo === tipos_de_simbolos_1.default.EOF;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.avancarEDevolverAnterior = function () {
+        if (!this.estaNoFinal())
+            this.atual += 1;
+        return this.simboloAnterior();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.verificarSeSimboloAtualEIgualA = function () {
+        var argumentos = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            argumentos[_i] = arguments[_i];
+        }
+        for (var i = 0; i < argumentos.length; i++) {
+            var tipoAtual = argumentos[i];
+            if (this.verificarTipoSimboloAtual(tipoAtual)) {
+                this.avancarEDevolverAnterior();
+                return true;
+            }
+        }
+        return false;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.primario = function () {
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SUPER)) {
+            var palavraChave = this.simboloAnterior();
+            this.consumir(tipos_de_simbolos_1.default.PONTO, "Esperado '.' após 'super'.");
+            var metodo = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            return new construtos_1.Super(0, palavraChave, metodo);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.COLCHETE_ESQUERDO)) {
+            var valores = [];
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.COLCHETE_DIREITO)) {
+                return new construtos_1.Vetor(0, []);
+            }
+            while (!this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.COLCHETE_DIREITO)) {
+                var valor = this.atribuir();
+                valores.push(valor);
+                if (this.simboloAtual().tipo !==
+                    tipos_de_simbolos_1.default.COLCHETE_DIREITO) {
+                    this.consumir(tipos_de_simbolos_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                }
+            }
+            return new construtos_1.Vetor(0, valores);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CHAVE_ESQUERDA)) {
+            var chaves = [];
+            var valores = [];
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CHAVE_DIREITA)) {
+                return new construtos_1.Dicionario(0, [], []);
+            }
+            while (!this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CHAVE_DIREITA)) {
+                var chave = this.atribuir();
+                this.consumir(tipos_de_simbolos_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                var valor = this.atribuir();
+                chaves.push(chave);
+                valores.push(valor);
+                if (this.simboloAtual().tipo !== tipos_de_simbolos_1.default.CHAVE_DIREITA) {
+                    this.consumir(tipos_de_simbolos_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                }
+            }
+            return new construtos_1.Dicionario(0, chaves, valores);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.FUNÇÃO))
+            return this.corpoDaFuncao('função');
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.FALSO))
+            return new construtos_1.Literal(0, false);
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.VERDADEIRO))
+            return new construtos_1.Literal(0, true);
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.NULO))
+            return new construtos_1.Literal(0, null);
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.ISTO))
+            return new construtos_1.Isto(this.simboloAnterior());
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.NUMERO, tipos_de_simbolos_1.default.TEXTO)) {
+            return new construtos_1.Literal(0, this.simboloAnterior().literal);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.IDENTIFICADOR)) {
+            return new construtos_1.Variavel(this.simboloAnterior());
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO)) {
+            var expr = this.expressao();
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+            return new construtos_1.Agrupamento(0, expr);
+        }
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.IMPORTAR))
+            return this.declaracaoImportar();
+        throw this.erro(this.simboloAtual(), 'Esperado expressão.');
+    };
+    AvaliadorSintaticoEguaClassico.prototype.finalizarChamada = function (entidadeChamada) {
+        var argumentos = [];
+        if (!this.verificarTipoSimboloAtual(tipos_de_simbolos_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(tipos_de_simbolos_1.default.VIRGULA));
+        }
+        var parenteseDireito = this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        return new construtos_1.Chamada(entidadeChamada, parenteseDireito, argumentos);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.chamar = function () {
+        var expressao = this.primario();
+        while (true) {
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO)) {
+                expressao = this.finalizarChamada(expressao);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PONTO)) {
+                var nome = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                expressao = new construtos_1.AcessoMetodo(expressao, nome);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.COLCHETE_ESQUERDO)) {
+                var indice = this.expressao();
+                var simboloFechamento = this.consumir(tipos_de_simbolos_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                expressao = new construtos_1.AcessoIndiceVariavel(expressao, indice, simboloFechamento);
+            }
+            else {
+                break;
+            }
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.unario = function () {
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.NEGACAO, tipos_de_simbolos_1.default.SUBTRACAO, tipos_de_simbolos_1.default.BIT_NOT)) {
+            var operador = this.simboloAnterior();
+            var direito = this.unario();
+            return new construtos_1.Unario(operador, direito);
+        }
+        return this.chamar();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.exponenciacao = function () {
+        var expressao = this.unario();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.EXPONENCIACAO)) {
+            var operador = this.simboloAnterior();
+            var direito = this.unario();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.multiplicar = function () {
+        var expressao = this.exponenciacao();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.DIVISAO, tipos_de_simbolos_1.default.MULTIPLICACAO, tipos_de_simbolos_1.default.MODULO)) {
+            var operador = this.simboloAnterior();
+            var direito = this.exponenciacao();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.adicionar = function () {
+        var expressao = this.multiplicar();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SUBTRACAO, tipos_de_simbolos_1.default.ADICAO)) {
+            var operador = this.simboloAnterior();
+            var direito = this.multiplicar();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.bitFill = function () {
+        var expressao = this.adicionar();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.MENOR_MENOR, tipos_de_simbolos_1.default.MAIOR_MAIOR)) {
+            var operador = this.simboloAnterior();
+            var direito = this.adicionar();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.bitE = function () {
+        var expressao = this.bitFill();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.BIT_AND)) {
+            var operador = this.simboloAnterior();
+            var direito = this.bitFill();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.bitOu = function () {
+        var expressao = this.bitE();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.BIT_OR, tipos_de_simbolos_1.default.BIT_XOR)) {
+            var operador = this.simboloAnterior();
+            var direito = this.bitE();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.comparar = function () {
+        var expressao = this.bitOu();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.MAIOR, tipos_de_simbolos_1.default.MAIOR_IGUAL, tipos_de_simbolos_1.default.MENOR, tipos_de_simbolos_1.default.MENOR_IGUAL)) {
+            var operador = this.simboloAnterior();
+            var direito = this.bitOu();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.comparacaoIgualdade = function () {
+        var expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.DIFERENTE, tipos_de_simbolos_1.default.IGUAL_IGUAL)) {
+            var operador = this.simboloAnterior();
+            var direito = this.comparar();
+            expressao = new construtos_1.Binario(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.em = function () {
+        var expressao = this.comparacaoIgualdade();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.EM)) {
+            var operador = this.simboloAnterior();
+            var direito = this.comparacaoIgualdade();
+            expressao = new construtos_1.Logico(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.e = function () {
+        var expressao = this.em();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.E)) {
+            var operador = this.simboloAnterior();
+            var direito = this.em();
+            expressao = new construtos_1.Logico(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.ou = function () {
+        var expressao = this.e();
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.OU)) {
+            var operador = this.simboloAnterior();
+            var direito = this.e();
+            expressao = new construtos_1.Logico(expressao, operador, direito);
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.atribuir = function () {
+        var expressao = this.ou();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.IGUAL)) {
+            var igual = this.simboloAnterior();
+            var valor = this.atribuir();
+            if (expressao instanceof construtos_1.Variavel) {
+                var simbolo = expressao.simbolo;
+                return new construtos_1.Atribuir(simbolo, valor);
+            }
+            else if (expressao instanceof construtos_1.AcessoMetodo) {
+                var get = expressao;
+                return new construtos_1.Conjunto(0, get.objeto, get.simbolo, valor);
+            }
+            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                return new construtos_1.AtribuicaoSobrescrita(0, expressao.entidadeChamada, expressao.indice, valor);
+            }
+            this.erro(igual, 'Tarefa de atribuição inválida');
+        }
+        return expressao;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.expressao = function () {
+        return this.atribuir();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoEscreva = function () {
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        var valor = this.expressao();
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após o valor.");
+        return new declaracoes_1.Escreva(valor);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoExpressao = function () {
+        var expressao = this.expressao();
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
+        return new declaracoes_1.Expressao(expressao);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.blocoEscopo = function () {
+        var declaracoes = [];
+        while (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
+            declaracoes.push(this.declaracao());
+        }
+        this.consumir(tipos_de_simbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
+        return declaracoes;
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoSe = function () {
+        var simboloSe = this.simboloAnterior();
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
+        var condicao = this.expressao();
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
+        var caminhoEntao = this.resolverDeclaracao();
+        var caminhosSeSenao = [];
+        while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SENÃOSE)) {
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'senãose'.");
+            var condicaoSeSenao = this.expressao();
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' apóes codição do 'senãose.");
+            var caminho = this.resolverDeclaracao();
+            caminhosSeSenao.push({
+                condicao: condicaoSeSenao,
+                caminho: caminho,
+            });
+        }
+        var caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SENÃO)) {
+            caminhoSenao = this.resolverDeclaracao();
+        }
+        return new declaracoes_1.Se(Number(simboloSe.linha), condicao, caminhoEntao, caminhosSeSenao, caminhoSenao);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoEnquanto = function () {
+        try {
+            this.ciclos += 1;
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
+            var condicao = this.expressao();
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após condicional.");
+            var corpo = this.resolverDeclaracao();
+            return new declaracoes_1.Enquanto(condicao, corpo);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoPara = function () {
+        try {
+            var simboloPara = this.simboloAnterior();
+            this.ciclos += 1;
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
+            var inicializador = void 0;
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PONTO_E_VIRGULA)) {
+                inicializador = null;
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.VARIAVEL)) {
+                inicializador = this.declaracaoDeVariavel();
+            }
+            else {
+                inicializador = this.declaracaoExpressao();
+            }
+            var condicao = null;
+            if (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PONTO_E_VIRGULA)) {
+                condicao = this.expressao();
+            }
+            this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após valores da condicional");
+            var incrementar = null;
+            if (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PARENTESE_DIREITO)) {
+                incrementar = this.expressao();
+            }
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
+            var corpo = this.resolverDeclaracao();
+            return new declaracoes_1.Para(Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoSustar = function () {
+        if (this.ciclos < 1) {
+            this.erro(this.simboloAnterior(), "'pausa' deve estar dentro de um loop.");
+        }
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'pausa'.");
+        return new declaracoes_1.Sustar();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoContinua = function () {
+        if (this.ciclos < 1) {
+            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
+        }
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
+        return new declaracoes_1.Continua();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoRetorna = function () {
+        var palavraChave = this.simboloAnterior();
+        var valor = null;
+        if (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PONTO_E_VIRGULA)) {
+            valor = this.expressao();
+        }
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após o retorno.");
+        return new declaracoes_1.Retorna(palavraChave, valor);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoEscolha = function () {
+        try {
+            this.ciclos += 1;
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '{' após 'escolha'.");
+            var condicao = this.expressao();
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado '}' após a condição de 'escolha'.");
+            this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
+            var caminhos = [];
+            var caminhoPadrao = null;
+            while (!this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CHAVE_DIREITA) &&
+                !this.estaNoFinal()) {
+                if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CASO)) {
+                    var branchConditions = [this.expressao()];
+                    this.consumir(tipos_de_simbolos_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
+                    while (this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CASO)) {
+                        this.consumir(tipos_de_simbolos_1.default.CASO, null);
+                        branchConditions.push(this.expressao());
+                        this.consumir(tipos_de_simbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                    }
+                    var declaracoes = [];
+                    do {
+                        declaracoes.push(this.resolverDeclaracao());
+                    } while (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CHAVE_DIREITA));
+                    caminhos.push({
+                        conditions: branchConditions,
+                        declaracoes: declaracoes,
+                    });
+                }
+                else if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PADRAO)) {
+                    if (caminhoPadrao !== null) {
+                        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simboloAtual(), "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                        this.erros.push(excecao);
+                        throw excecao;
+                    }
+                    this.consumir(tipos_de_simbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+                    var declaracoes = [];
+                    do {
+                        declaracoes.push(this.resolverDeclaracao());
+                    } while (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CHAVE_DIREITA));
+                    caminhoPadrao = {
+                        declaracoes: declaracoes,
+                    };
+                }
+            }
+            return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoImportar = function () {
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        var caminho = this.expressao();
+        var simboloFechamento = this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        return new declaracoes_1.Importar(caminho, simboloFechamento);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoTente = function () {
+        this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
+        var tryBlock = this.blocoEscopo();
+        var catchBlock = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PEGUE)) {
+            this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            catchBlock = this.blocoEscopo();
+        }
+        var elseBlock = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SENÃO)) {
+            this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            elseBlock = this.blocoEscopo();
+        }
+        var finallyBlock = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.FINALMENTE)) {
+            this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            finallyBlock = this.blocoEscopo();
+        }
+        return new declaracoes_1.Tente(tryBlock, catchBlock, elseBlock, finallyBlock);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoFazer = function () {
+        try {
+            this.ciclos += 1;
+            var caminhoFazer = this.resolverDeclaracao();
+            this.consumir(tipos_de_simbolos_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
+            var condicaoEnquanto = this.expressao();
+            this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
+            return new declaracoes_1.Fazer(caminhoFazer, condicaoEnquanto);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.resolverDeclaracao = function () {
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.FAZER))
+            return this.declaracaoFazer();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.TENTE))
+            return this.declaracaoTente();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.ESCOLHA))
+            return this.declaracaoEscolha();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.RETORNA))
+            return this.declaracaoRetorna();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CONTINUA))
+            return this.declaracaoContinua();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PAUSA))
+            return this.declaracaoSustar();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.PARA))
+            return this.declaracaoPara();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.ENQUANTO))
+            return this.declaracaoEnquanto();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.SE))
+            return this.declaracaoSe();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.ESCREVA))
+            return this.declaracaoEscreva();
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CHAVE_ESQUERDA))
+            return new declaracoes_1.Bloco(this.blocoEscopo());
+        return this.declaracaoExpressao();
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoDeVariavel = function () {
+        var nome = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
+        var inicializador = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.IGUAL)) {
+            inicializador = this.expressao();
+        }
+        this.consumir(tipos_de_simbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após a declaração da variável.");
+        return new declaracoes_1.Var(nome, inicializador);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.funcao = function (kind) {
+        var nome = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, "Esperado nome ".concat(kind, "."));
+        return new declaracoes_1.Funcao(nome, this.corpoDaFuncao(kind));
+    };
+    AvaliadorSintaticoEguaClassico.prototype.corpoDaFuncao = function (kind) {
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' ap\u00F3s o nome ".concat(kind, "."));
+        var parametros = [];
+        if (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.PARENTESE_DIREITO)) {
+            do {
+                if (parametros.length >= 255) {
+                    this.erro(this.simboloAtual(), 'Não pode haver mais de 255 parâmetros');
+                }
+                var paramObj = {};
+                if (this.simboloAtual().tipo === tipos_de_simbolos_1.default.MULTIPLICACAO) {
+                    this.consumir(tipos_de_simbolos_1.default.MULTIPLICACAO, null);
+                    paramObj['tipo'] = 'wildcard';
+                }
+                else {
+                    paramObj['tipo'] = 'standard';
+                }
+                paramObj['nome'] = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+                if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.IGUAL)) {
+                    paramObj['default'] = this.primario();
+                }
+                parametros.push(paramObj);
+                if (paramObj['tipo'] === 'wildcard')
+                    break;
+            } while (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.VIRGULA));
+        }
+        this.consumir(tipos_de_simbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do ".concat(kind, "."));
+        var corpo = this.blocoEscopo();
+        return new construtos_1.Funcao(0, parametros, corpo);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracaoDeClasse = function () {
+        var nome = this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        var superClasse = null;
+        if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.HERDA)) {
+            this.consumir(tipos_de_simbolos_1.default.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            superClasse = new construtos_1.Variavel(this.simboloAnterior());
+        }
+        this.consumir(tipos_de_simbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
+        var metodos = [];
+        while (!this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
+            metodos.push(this.funcao('método'));
+        }
+        this.consumir(tipos_de_simbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
+        return new declaracoes_1.Classe(nome, superClasse, metodos);
+    };
+    AvaliadorSintaticoEguaClassico.prototype.declaracao = function () {
+        try {
+            if (this.verificarTipoSimboloAtual(tipos_de_simbolos_1.default.FUNÇÃO) &&
+                this.verificarTipoProximoSimbolo(tipos_de_simbolos_1.default.IDENTIFICADOR)) {
+                this.consumir(tipos_de_simbolos_1.default.FUNÇÃO, null);
+                return this.funcao('função');
+            }
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.VARIAVEL))
+                return this.declaracaoDeVariavel();
+            if (this.verificarSeSimboloAtualEIgualA(tipos_de_simbolos_1.default.CLASSE))
+                return this.declaracaoDeClasse();
+            return this.resolverDeclaracao();
+        }
+        catch (erro) {
+            this.sincronizar();
+            return null;
+        }
+    };
+    AvaliadorSintaticoEguaClassico.prototype.analisar = function (simbolos) {
+        this.erros = [];
+        this.atual = 0;
+        this.ciclos = 0;
+        this.simbolos = simbolos || [];
+        var declaracoes = [];
+        while (!this.estaNoFinal()) {
+            declaracoes.push(this.declaracao());
+        }
+        return {
+            declaracoes: declaracoes,
+            erros: this.erros
+        };
+    };
+    return AvaliadorSintaticoEguaClassico;
+}());
+exports.AvaliadorSintaticoEguaClassico = AvaliadorSintaticoEguaClassico;
+//# sourceMappingURL=egua-classico.js.map