@designliquido/delegua 0.0.1 → 0.1.2

package/src/avaliador-sintatico/index.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+var tiposDeSimbolos_1 = require("../tiposDeSimbolos");
+var construtos_1 = require("../construtos");
+var declaracoes_1 = require("../declaracoes");
+var parser_error_1 = require("./parser-error");
+/**
+ * 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 Parser = /** @class */ (function () {
+    function Parser(Delegua, simbolos) {
+        this.simbolos = simbolos;
+        this.Delegua = Delegua;
+        this.atual = 0;
+        this.ciclos = 0;
+    }
+    Parser.prototype.sincronizar = function () {
+        this.avancar();
+        while (!this.estaNoFinal()) {
+            if (this.voltar().tipo === tiposDeSimbolos_1.default.PONTO_E_VIRGULA)
+                return;
+            switch (this.peek().tipo) {
+                case tiposDeSimbolos_1.default.CLASSE:
+                case tiposDeSimbolos_1.default.FUNCAO:
+                case tiposDeSimbolos_1.default.VAR:
+                case tiposDeSimbolos_1.default.PARA:
+                case tiposDeSimbolos_1.default.SE:
+                case tiposDeSimbolos_1.default.ENQUANTO:
+                case tiposDeSimbolos_1.default.ESCREVA:
+                case tiposDeSimbolos_1.default.RETORNA:
+                    return;
+            }
+            this.avancar();
+        }
+    };
+    Parser.prototype.erro = function (simbolo, mensagemDeErro) {
+        this.Delegua.erro(simbolo, mensagemDeErro);
+        return new parser_error_1.ErroAvaliador();
+    };
+    Parser.prototype.consumir = function (tipo, mensagemDeErro) {
+        if (this.verificar(tipo))
+            return this.avancar();
+        else
+            throw this.erro(this.peek(), mensagemDeErro);
+    };
+    Parser.prototype.verificar = function (tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.peek().tipo === tipo;
+    };
+    Parser.prototype.verificarProximo = function (tipo) {
+        if (this.estaNoFinal())
+            return false;
+        return this.simbolos[this.atual + 1].tipo === tipo;
+    };
+    Parser.prototype.peek = function () {
+        return this.simbolos[this.atual];
+    };
+    Parser.prototype.voltar = function () {
+        return this.simbolos[this.atual - 1];
+    };
+    Parser.prototype.seek = function (posicao) {
+        return this.simbolos[this.atual + posicao];
+    };
+    Parser.prototype.estaNoFinal = function () {
+        return this.peek().tipo === tiposDeSimbolos_1.default.EOF;
+    };
+    Parser.prototype.avancar = function () {
+        if (!this.estaNoFinal())
+            this.atual += 1;
+        return this.voltar();
+    };
+    Parser.prototype.match = 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.verificar(tipoAtual)) {
+                this.avancar();
+                return true;
+            }
+        }
+        return false;
+    };
+    Parser.prototype.primario = function () {
+        if (this.match(tiposDeSimbolos_1.default.SUPER)) {
+            var palavraChave = this.voltar();
+            this.consumir(tiposDeSimbolos_1.default.DOT, "Esperado '.' após 'super'.");
+            var metodo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do método da SuperClasse.");
+            return new construtos_1.Super(palavraChave, metodo);
+        }
+        if (this.match(tiposDeSimbolos_1.default.COLCHETE_ESQUERDO)) {
+            var valores = [];
+            if (this.match(tiposDeSimbolos_1.default.COLCHETE_DIREITO)) {
+                return new construtos_1.Vetor([]);
+            }
+            while (!this.match(tiposDeSimbolos_1.default.COLCHETE_DIREITO)) {
+                var valor = this.atribuir();
+                valores.push(valor);
+                if (this.peek().tipo !== tiposDeSimbolos_1.default.COLCHETE_DIREITO) {
+                    this.consumir(tiposDeSimbolos_1.default.COMMA, "Esperado vírgula antes da próxima expressão.");
+                }
+            }
+            return new construtos_1.Vetor(valores);
+        }
+        if (this.match(tiposDeSimbolos_1.default.CHAVE_ESQUERDA)) {
+            var chaves = [];
+            var valores = [];
+            if (this.match(tiposDeSimbolos_1.default.CHAVE_DIREITA)) {
+                return new construtos_1.Dicionario([], []);
+            }
+            while (!this.match(tiposDeSimbolos_1.default.CHAVE_DIREITA)) {
+                var chave = this.atribuir();
+                this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                var valor = this.atribuir();
+                chaves.push(chave);
+                valores.push(valor);
+                if (this.peek().tipo !== tiposDeSimbolos_1.default.CHAVE_DIREITA) {
+                    this.consumir(tiposDeSimbolos_1.default.COMMA, "Esperado vírgula antes da próxima expressão.");
+                }
+            }
+            return new construtos_1.Dicionario(chaves, valores);
+        }
+        if (this.match(tiposDeSimbolos_1.default.FUNCAO))
+            return this.corpoDaFuncao("funcao");
+        if (this.match(tiposDeSimbolos_1.default.FALSO))
+            return new construtos_1.Literal(false);
+        if (this.match(tiposDeSimbolos_1.default.VERDADEIRO))
+            return new construtos_1.Literal(true);
+        if (this.match(tiposDeSimbolos_1.default.NULO))
+            return new construtos_1.Literal(null);
+        if (this.match(tiposDeSimbolos_1.default.ISTO))
+            return new construtos_1.Isto(this.voltar());
+        if (this.match(tiposDeSimbolos_1.default.NUMERO, tiposDeSimbolos_1.default.TEXTO)) {
+            return new construtos_1.Literal(this.voltar().literal);
+        }
+        if (this.match(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
+            return new construtos_1.Variavel(this.voltar());
+        }
+        if (this.match(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO)) {
+            var expr = this.expressao();
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+            return new construtos_1.Grouping(expr);
+        }
+        if (this.match(tiposDeSimbolos_1.default.IMPORTAR))
+            return this.importStatement();
+        throw this.erro(this.peek(), "Esperado expressão.");
+    };
+    Parser.prototype.finalizarChamada = function (callee) {
+        var argumentos = [];
+        if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+            do {
+                if (argumentos.length >= 255) {
+                    throw this.erro(this.peek(), "Não pode haver mais de 255 argumentos.");
+                }
+                argumentos.push(this.expressao());
+            } while (this.match(tiposDeSimbolos_1.default.COMMA));
+        }
+        var parenteseDireito = this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        return new construtos_1.Call(callee, parenteseDireito, argumentos);
+    };
+    Parser.prototype.chamar = function () {
+        var expr = this.primario();
+        while (true) {
+            if (this.match(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO)) {
+                expr = this.finalizarChamada(expr);
+            }
+            else if (this.match(tiposDeSimbolos_1.default.DOT)) {
+                var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                expr = new construtos_1.Get(expr, nome);
+            }
+            else if (this.match(tiposDeSimbolos_1.default.COLCHETE_ESQUERDO)) {
+                var indice = this.expressao();
+                var closeBracket = this.consumir(tiposDeSimbolos_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                expr = new construtos_1.Subscript(expr, indice, closeBracket);
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    };
+    Parser.prototype.unario = function () {
+        if (this.match(tiposDeSimbolos_1.default.NEGACAO, tiposDeSimbolos_1.default.SUBTRACAO, tiposDeSimbolos_1.default.BIT_NOT)) {
+            var operador = this.voltar();
+            var direito = this.unario();
+            return new construtos_1.Unario(operador, direito);
+        }
+        return this.chamar();
+    };
+    Parser.prototype.exponent = function () {
+        var expr = this.unario();
+        while (this.match(tiposDeSimbolos_1.default.EXPONENCIACAO)) {
+            var operador = this.voltar();
+            var direito = this.unario();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.multiplicar = function () {
+        var expr = this.exponent();
+        while (this.match(tiposDeSimbolos_1.default.DIVISAO, tiposDeSimbolos_1.default.MULTIPLICACAO, tiposDeSimbolos_1.default.MODULO)) {
+            var operador = this.voltar();
+            var direito = this.exponent();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.adicionar = function () {
+        var expr = this.multiplicar();
+        while (this.match(tiposDeSimbolos_1.default.SUBTRACAO, tiposDeSimbolos_1.default.ADICAO)) {
+            var operador = this.voltar();
+            var direito = this.multiplicar();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.bitFill = function () {
+        var expr = this.adicionar();
+        while (this.match(tiposDeSimbolos_1.default.MENOR_MENOR, tiposDeSimbolos_1.default.MAIOR_MAIOR)) {
+            var operador = this.voltar();
+            var direito = this.adicionar();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.bitE = function () {
+        var expr = this.bitFill();
+        while (this.match(tiposDeSimbolos_1.default.BIT_AND)) {
+            var operador = this.voltar();
+            var direito = this.bitFill();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.bitOu = function () {
+        var expr = this.bitE();
+        while (this.match(tiposDeSimbolos_1.default.BIT_OR, tiposDeSimbolos_1.default.BIT_XOR)) {
+            var operador = this.voltar();
+            var direito = this.bitE();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.comparar = function () {
+        var expr = this.bitOu();
+        while (this.match(tiposDeSimbolos_1.default.MAIOR, tiposDeSimbolos_1.default.MAIOR_IGUAL, tiposDeSimbolos_1.default.MENOR, tiposDeSimbolos_1.default.MENOR_IGUAL)) {
+            var operador = this.voltar();
+            var direito = this.bitOu();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.equality = function () {
+        var expr = this.comparar();
+        while (this.match(tiposDeSimbolos_1.default.DIFERENTE, tiposDeSimbolos_1.default.IGUAL_IGUAL)) {
+            var operador = this.voltar();
+            var direito = this.comparar();
+            expr = new construtos_1.Binario(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.em = function () {
+        var expr = this.equality();
+        while (this.match(tiposDeSimbolos_1.default.EM)) {
+            var operador = this.voltar();
+            var direito = this.equality();
+            expr = new construtos_1.Logical(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.e = function () {
+        var expr = this.em();
+        while (this.match(tiposDeSimbolos_1.default.E)) {
+            var operador = this.voltar();
+            var direito = this.em();
+            expr = new construtos_1.Logical(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.ou = function () {
+        var expr = this.e();
+        while (this.match(tiposDeSimbolos_1.default.OU)) {
+            var operador = this.voltar();
+            var direito = this.e();
+            expr = new construtos_1.Logical(expr, operador, direito);
+        }
+        return expr;
+    };
+    Parser.prototype.atribuir = function () {
+        var expr = this.ou();
+        if (this.match(tiposDeSimbolos_1.default.IGUAL) ||
+            this.match(tiposDeSimbolos_1.default.MAIS_IGUAL)) {
+            var igual = this.voltar();
+            var valor = this.atribuir();
+            if (expr instanceof construtos_1.Variavel) {
+                var nome = expr.nome;
+                return new construtos_1.Atribuir(nome, valor);
+            }
+            else if (expr instanceof construtos_1.Get) {
+                var get = expr;
+                return new construtos_1.Conjunto(get.objeto, get.nome, valor);
+            }
+            else if (expr instanceof construtos_1.Subscript) {
+                return new construtos_1.AssignSubscript(expr.callee, expr.indice, valor);
+            }
+            this.erro(igual, "Tarefa de atribuição inválida");
+        }
+        return expr;
+    };
+    Parser.prototype.expressao = function () {
+        return this.atribuir();
+    };
+    Parser.prototype.declaracaoMostrar = function () {
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        var valor = this.expressao();
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após o valor.");
+        return new declaracoes_1.Escreva(valor);
+    };
+    Parser.prototype.expressionStatement = function () {
+        var expr = this.expressao();
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
+        return new declaracoes_1.Expressao(expr);
+    };
+    Parser.prototype.block = function () {
+        var declaracoes = [];
+        while (!this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
+            declaracoes.push(this.declaracao());
+        }
+        this.consumir(tiposDeSimbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
+        return declaracoes;
+    };
+    Parser.prototype.declaracaoSe = function () {
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
+        var condicao = this.expressao();
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
+        var thenBranch = this.statement();
+        var elifBranches = [];
+        while (this.match(tiposDeSimbolos_1.default.SENAOSE)) {
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose'.");
+            var elifCondition = this.expressao();
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' apóes codição do 'senaose.");
+            var branch = this.statement();
+            elifBranches.push({
+                condition: elifCondition,
+                branch: branch,
+            });
+        }
+        var elseBranch = null;
+        if (this.match(tiposDeSimbolos_1.default.SENAO)) {
+            elseBranch = this.statement();
+        }
+        return new declaracoes_1.Se(condicao, thenBranch, elifBranches, elseBranch);
+    };
+    Parser.prototype.whileStatement = function () {
+        try {
+            this.ciclos += 1;
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
+            var condicao = this.expressao();
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após condicional.");
+            var corpo = this.statement();
+            return new declaracoes_1.Enquanto(condicao, corpo);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    Parser.prototype.forStatement = function () {
+        try {
+            this.ciclos += 1;
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
+            var inicializador = void 0;
+            if (this.match(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
+                inicializador = null;
+            }
+            else if (this.match(tiposDeSimbolos_1.default.VAR)) {
+                inicializador = this.declaracaoDeVariavel();
+            }
+            else {
+                inicializador = this.expressionStatement();
+            }
+            var condicao = null;
+            if (!this.verificar(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
+                condicao = this.expressao();
+            }
+            this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após valores da condicional");
+            var incrementar = null;
+            if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+                incrementar = this.expressao();
+            }
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
+            var corpo = this.statement();
+            return new declaracoes_1.Para(inicializador, condicao, incrementar, corpo);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    Parser.prototype.breakStatement = function () {
+        if (this.ciclos < 1) {
+            this.erro(this.voltar(), "'pausa' deve estar dentro de um loop.");
+        }
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'pausa'.");
+        return new declaracoes_1.Pausa();
+    };
+    Parser.prototype.declaracaoContinue = function () {
+        if (this.ciclos < 1) {
+            this.erro(this.voltar(), "'continua' precisa estar em um laço de repetição.");
+        }
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
+        return new declaracoes_1.Continua();
+    };
+    Parser.prototype.declaracaoRetorna = function () {
+        var palavraChave = this.voltar();
+        var valor = null;
+        if (!this.verificar(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
+            valor = this.expressao();
+        }
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após o retorno.");
+        return new declaracoes_1.Retorna(palavraChave, valor);
+    };
+    Parser.prototype.declaracaoEscolha = function () {
+        try {
+            this.ciclos += 1;
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '{' após 'escolha'.");
+            var condicao = this.expressao();
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado '}' após a condição de 'escolha'.");
+            this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
+            var branches = [];
+            var defaultBranch = null;
+            while (!this.match(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
+                !this.estaNoFinal()) {
+                if (this.match(tiposDeSimbolos_1.default.CASO)) {
+                    var branchConditions = [this.expressao()];
+                    this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
+                    while (this.verificar(tiposDeSimbolos_1.default.CASO)) {
+                        this.consumir(tiposDeSimbolos_1.default.CASO, null);
+                        branchConditions.push(this.expressao());
+                        this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                    }
+                    var stmts = [];
+                    do {
+                        stmts.push(this.statement());
+                    } while (!this.verificar(tiposDeSimbolos_1.default.CASO) &&
+                        !this.verificar(tiposDeSimbolos_1.default.PADRAO) &&
+                        !this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA));
+                    branches.push({
+                        conditions: branchConditions,
+                        stmts: stmts,
+                    });
+                }
+                else if (this.match(tiposDeSimbolos_1.default.PADRAO)) {
+                    if (defaultBranch !== null)
+                        throw new parser_error_1.ErroAvaliador("Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                    this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+                    var stmts = [];
+                    do {
+                        stmts.push(this.statement());
+                    } while (!this.verificar(tiposDeSimbolos_1.default.CASO) &&
+                        !this.verificar(tiposDeSimbolos_1.default.PADRAO) &&
+                        !this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA));
+                    defaultBranch = {
+                        stmts: stmts,
+                    };
+                }
+            }
+            return new declaracoes_1.Escolha(condicao, branches, defaultBranch);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    Parser.prototype.importStatement = function () {
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        var caminho = this.expressao();
+        var closeBracket = this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        return new declaracoes_1.Importar(caminho, closeBracket);
+    };
+    Parser.prototype.tryStatement = function () {
+        this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
+        var tryBlock = this.block();
+        var catchBlock = null;
+        if (this.match(tiposDeSimbolos_1.default.PEGUE)) {
+            this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            catchBlock = this.block();
+        }
+        var elseBlock = null;
+        if (this.match(tiposDeSimbolos_1.default.SENAO)) {
+            this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            elseBlock = this.block();
+        }
+        var finallyBlock = null;
+        if (this.match(tiposDeSimbolos_1.default.FINALMENTE)) {
+            this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+            finallyBlock = this.block();
+        }
+        return new declaracoes_1.Tente(tryBlock, catchBlock, elseBlock, finallyBlock);
+    };
+    Parser.prototype.doStatement = function () {
+        try {
+            this.ciclos += 1;
+            var doBranch = this.statement();
+            this.consumir(tiposDeSimbolos_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
+            var whileCondition = this.expressao();
+            this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
+            return new declaracoes_1.Fazer(doBranch, whileCondition);
+        }
+        finally {
+            this.ciclos -= 1;
+        }
+    };
+    Parser.prototype.statement = function () {
+        if (this.match(tiposDeSimbolos_1.default.FAZER))
+            return this.doStatement();
+        if (this.match(tiposDeSimbolos_1.default.TENTE))
+            return this.tryStatement();
+        if (this.match(tiposDeSimbolos_1.default.ESCOLHA))
+            return this.declaracaoEscolha();
+        if (this.match(tiposDeSimbolos_1.default.RETORNA))
+            return this.declaracaoRetorna();
+        if (this.match(tiposDeSimbolos_1.default.CONTINUA))
+            return this.declaracaoContinue();
+        if (this.match(tiposDeSimbolos_1.default.PAUSA))
+            return this.breakStatement();
+        if (this.match(tiposDeSimbolos_1.default.PARA))
+            return this.forStatement();
+        if (this.match(tiposDeSimbolos_1.default.ENQUANTO))
+            return this.whileStatement();
+        if (this.match(tiposDeSimbolos_1.default.SE))
+            return this.declaracaoSe();
+        if (this.match(tiposDeSimbolos_1.default.ESCREVA))
+            return this.declaracaoMostrar();
+        if (this.match(tiposDeSimbolos_1.default.CHAVE_ESQUERDA))
+            return new declaracoes_1.Block(this.block());
+        return this.expressionStatement();
+    };
+    Parser.prototype.declaracaoDeVariavel = function () {
+        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome de variável.");
+        var inicializador = null;
+        if (this.match(tiposDeSimbolos_1.default.IGUAL) ||
+            this.match(tiposDeSimbolos_1.default.MAIS_IGUAL)) {
+            inicializador = this.expressao();
+        }
+        this.consumir(tiposDeSimbolos_1.default.PONTO_E_VIRGULA, "Esperado ';' após a declaração da variável.");
+        return new declaracoes_1.Var(nome, inicializador);
+    };
+    Parser.prototype.funcao = function (kind) {
+        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome ".concat(kind, "."));
+        return new declaracoes_1.Funcao(nome, this.corpoDaFuncao(kind));
+    };
+    Parser.prototype.corpoDaFuncao = function (kind) {
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' ap\u00F3s o nome ".concat(kind, "."));
+        var parametros = [];
+        if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+            do {
+                if (parametros.length >= 255) {
+                    this.erro(this.peek(), "Não pode haver mais de 255 parâmetros");
+                }
+                var paramObj = {};
+                if (this.peek().tipo === tiposDeSimbolos_1.default.MULTIPLICACAO) {
+                    this.consumir(tiposDeSimbolos_1.default.MULTIPLICACAO, null);
+                    paramObj["tipo"] = "wildcard";
+                }
+                else {
+                    paramObj["tipo"] = "standard";
+                }
+                paramObj["nome"] = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do parâmetro.");
+                if (this.match(tiposDeSimbolos_1.default.IGUAL)) {
+                    paramObj["default"] = this.primario();
+                }
+                parametros.push(paramObj);
+                if (paramObj["tipo"] === "wildcard")
+                    break;
+            } while (this.match(tiposDeSimbolos_1.default.COMMA));
+        }
+        this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do ".concat(kind, "."));
+        var corpo = this.block();
+        return new declaracoes_1.Funcao(parametros, corpo);
+    };
+    Parser.prototype.declaracaoDeClasse = function () {
+        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome da classe.");
+        var superClasse = null;
+        if (this.match(tiposDeSimbolos_1.default.HERDA)) {
+            this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome da SuperClasse.");
+            superClasse = new construtos_1.Variavel(this.voltar());
+        }
+        this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
+        var metodos = [];
+        while (!this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
+            !this.estaNoFinal()) {
+            metodos.push(this.funcao("método"));
+        }
+        this.consumir(tiposDeSimbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
+        return new declaracoes_1.Classe(nome, superClasse, metodos);
+    };
+    Parser.prototype.declaracao = function () {
+        try {
+            if (this.verificar(tiposDeSimbolos_1.default.FUNCAO) &&
+                this.verificarProximo(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
+                this.consumir(tiposDeSimbolos_1.default.FUNCAO, null);
+                return this.funcao("funcao");
+            }
+            if (this.match(tiposDeSimbolos_1.default.VAR))
+                return this.declaracaoDeVariavel();
+            if (this.match(tiposDeSimbolos_1.default.CLASSE))
+                return this.declaracaoDeClasse();
+            return this.statement();
+        }
+        catch (erro) {
+            this.sincronizar();
+            return null;
+        }
+    };
+    Parser.prototype.analisar = function (simbolos) {
+        if (simbolos) {
+            this.simbolos = simbolos;
+        }
+        var declaracoes = [];
+        while (!this.estaNoFinal()) {
+            declaracoes.push(this.declaracao());
+        }
+        return declaracoes;
+    };
+    return Parser;
+}());
+exports.Parser = Parser;
+//# sourceMappingURL=index.js.map