@designliquido/delegua 0.2.0 → 0.2.3

package/src/interpretador/index.js

@@ -1,664 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interpretador = void 0;
-var tiposDeSimbolos_1 = require("../tiposDeSimbolos");
-var ambiente_1 = require("../ambiente");
-var delegua_1 = require("../delegua");
-var biblioteca_global_1 = require("../bibliotecas/biblioteca-global");
-var caminho = require("path");
-var fs = require("fs");
-var importar_biblioteca_1 = require("../bibliotecas/importar-biblioteca");
-var chamavel_1 = require("../estruturas/chamavel");
-var funcao_padrao_1 = require("../estruturas/funcao-padrao");
-var classe_1 = require("../estruturas/classe");
-var funcao_1 = require("../estruturas/funcao");
-var instancia_1 = require("../estruturas/instancia");
-var modulo_1 = require("../estruturas/modulo");
-var excecoes_1 = require("../excecoes");
-/**
- * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser)
- * e de fato executa a lógica de programação descrita no código.
- */
-var Interpretador = /** @class */ (function () {
-    function Interpretador(Delegua, diretorioBase) {
-        this.Delegua = Delegua;
-        this.diretorioBase = diretorioBase;
-        this.global = new ambiente_1.Ambiente();
-        this.ambiente = this.global;
-        this.locais = new Map();
-        this.global = (0, biblioteca_global_1.default)(this, this.global);
-    }
-    Interpretador.prototype.resolver = function (expr, depth) {
-        this.locais.set(expr, depth);
-    };
-    Interpretador.prototype.visitarExpressaoLiteral = function (expr) {
-        return expr.valor;
-    };
-    Interpretador.prototype.avaliar = function (expr) {
-        if (expr.aceitar) {
-            return expr.aceitar(this);
-        }
-    };
-    Interpretador.prototype.visitarExpressaoAgrupamento = function (expr) {
-        return this.avaliar(expr.expressao);
-    };
-    Interpretador.prototype.eVerdadeiro = function (objeto) {
-        if (objeto === null)
-            return false;
-        if (typeof objeto === "boolean")
-            return Boolean(objeto);
-        return true;
-    };
-    Interpretador.prototype.verificarOperandoNumero = function (operador, operando) {
-        if (typeof operando === "number")
-            return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, "Operando precisa ser um número.");
-    };
-    Interpretador.prototype.visitarExpressaoUnaria = function (expr) {
-        var direita = this.avaliar(expr.direita);
-        switch (expr.operador.tipo) {
-            case tiposDeSimbolos_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expr.operador, direita);
-                return -direita;
-            case tiposDeSimbolos_1.default.NEGACAO:
-                return !this.eVerdadeiro(direita);
-            case tiposDeSimbolos_1.default.BIT_NOT:
-                return ~direita;
-        }
-        return null;
-    };
-    Interpretador.prototype.eIgual = function (esquerda, direita) {
-        if (esquerda === null && direita === null)
-            return true;
-        if (esquerda === null)
-            return false;
-        return esquerda === direita;
-    };
-    Interpretador.prototype.verificarOperandosNumeros = function (operador, direita, esquerda) {
-        if (typeof direita === "number" && typeof esquerda === "number")
-            return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, "Operandos precisam ser números.");
-    };
-    Interpretador.prototype.visitarExpressaoBinaria = function (expr) {
-        var esquerda = this.avaliar(expr.esquerda);
-        var direita = this.avaliar(expr.direita);
-        switch (expr.operador.tipo) {
-            case tiposDeSimbolos_1.default.EXPONENCIACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Math.pow(esquerda, direita);
-            case tiposDeSimbolos_1.default.MAIOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) > Number(direita);
-            case tiposDeSimbolos_1.default.MAIOR_IGUAL:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) >= Number(direita);
-            case tiposDeSimbolos_1.default.MENOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) < Number(direita);
-            case tiposDeSimbolos_1.default.MENOR_IGUAL:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) <= Number(direita);
-            case tiposDeSimbolos_1.default.SUBTRACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) - Number(direita);
-            case tiposDeSimbolos_1.default.ADICAO:
-                if (typeof esquerda === "number" && typeof direita === "number") {
-                    return Number(esquerda) + Number(direita);
-                }
-                else {
-                    return String(esquerda) + String(direita);
-                }
-            case tiposDeSimbolos_1.default.DIVISAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) / Number(direita);
-            case tiposDeSimbolos_1.default.MULTIPLICACAO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) * Number(direita);
-            case tiposDeSimbolos_1.default.MODULO:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) % Number(direita);
-            case tiposDeSimbolos_1.default.BIT_AND:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) & Number(direita);
-            case tiposDeSimbolos_1.default.BIT_XOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) ^ Number(direita);
-            case tiposDeSimbolos_1.default.BIT_OR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) | Number(direita);
-            case tiposDeSimbolos_1.default.MENOR_MENOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) << Number(direita);
-            case tiposDeSimbolos_1.default.MAIOR_MAIOR:
-                this.verificarOperandosNumeros(expr.operador, esquerda, direita);
-                return Number(esquerda) >> Number(direita);
-            case tiposDeSimbolos_1.default.DIFERENTE:
-                return !this.eIgual(esquerda, direita);
-            case tiposDeSimbolos_1.default.IGUAL_IGUAL:
-                return this.eIgual(esquerda, direita);
-        }
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoDeChamada = function (expr) {
-        var entidadeChamada = this.avaliar(expr.entidadeChamada);
-        var argumentos = [];
-        for (var i = 0; i < expr.argumentos.length; i++) {
-            argumentos.push(this.avaliar(expr.argumentos[i]));
-        }
-        if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.parentese, "Só pode chamar função ou classe.");
-        }
-        var parametros;
-        if (entidadeChamada instanceof funcao_1.DeleguaFuncao) {
-            parametros = entidadeChamada.declaracao.parametros;
-        }
-        else if (entidadeChamada instanceof classe_1.DeleguaClasse) {
-            parametros = entidadeChamada.metodos.init
-                ? entidadeChamada.metodos.init.declaracao.parametros
-                : [];
-        }
-        else {
-            parametros = [];
-        }
-        // Isso aqui completa os parâmetros não preenchidos com nulos.
-        if (argumentos.length < entidadeChamada.aridade()) {
-            var diferenca = entidadeChamada.aridade() - argumentos.length;
-            for (var i = 0; i < diferenca; i++) {
-                argumentos.push(null);
-            }
-        }
-        else {
-            if (parametros &&
-                parametros.length > 0 &&
-                parametros[parametros.length - 1]["tipo"] === "wildcard") {
-                var novosArgumentos = argumentos.slice(0, parametros.length - 1);
-                novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
-                argumentos = novosArgumentos;
-            }
-        }
-        if (entidadeChamada instanceof funcao_padrao_1.FuncaoPadrao) {
-            return entidadeChamada.chamar(this, argumentos, expr.entidadeChamada.nome);
-        }
-        return entidadeChamada.chamar(this, argumentos);
-    };
-    Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expr) {
-        var valor = this.avaliar(expr.valor);
-        var distancia = this.locais.get(expr);
-        if (distancia !== undefined) {
-            this.ambiente.atribuirVariavelEm(distancia, expr.nome, valor);
-        }
-        else {
-            this.ambiente.atribuirVariavel(expr.nome, valor);
-        }
-        return valor;
-    };
-    Interpretador.prototype.procurarVariavel = function (nome, expr) {
-        var distancia = this.locais.get(expr);
-        if (distancia !== undefined) {
-            return this.ambiente.obterVariavelEm(distancia, nome.lexema);
-        }
-        else {
-            return this.global.obterVariavel(nome);
-        }
-    };
-    Interpretador.prototype.visitarExpressaoDeVariavel = function (expr) {
-        return this.procurarVariavel(expr.nome, expr);
-    };
-    Interpretador.prototype.visitarDeclaracaoDeExpressao = function (stmt) {
-        return this.avaliar(stmt.expressao);
-    };
-    Interpretador.prototype.visitarExpressaoLogica = function (expr) {
-        var esquerda = this.avaliar(expr.esquerda);
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.EM) {
-            var direita = this.avaliar(expr.direita);
-            if (Array.isArray(direita) || typeof direita === "string") {
-                return direita.includes(esquerda);
-            }
-            else if (direita.constructor === Object) {
-                return esquerda in direita;
-            }
-            else {
-                throw new excecoes_1.ErroEmTempoDeExecucao("Tipo de chamada inválida com 'em'.");
-            }
-        }
-        // se um estado for verdadeiro, retorna verdadeiro
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.OU) {
-            if (this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        // se um estado for falso, retorna falso
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.E) {
-            if (!this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        return this.avaliar(expr.direita);
-    };
-    Interpretador.prototype.visitarExpressaoSe = function (stmt) {
-        if (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
-            this.executar(stmt.thenBranch);
-            return null;
-        }
-        for (var i = 0; i < stmt.elifBranches.length; i++) {
-            var atual = stmt.elifBranches[i];
-            if (this.eVerdadeiro(this.avaliar(atual.condicao))) {
-                this.executar(atual.branch);
-                return null;
-            }
-        }
-        if (stmt.elseBranch !== null) {
-            this.executar(stmt.elseBranch);
-        }
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoPara = function (stmt) {
-        if (stmt.inicializador !== null) {
-            this.avaliar(stmt.inicializador);
-        }
-        while (true) {
-            if (stmt.condicao !== null) {
-                if (!this.eVerdadeiro(this.avaliar(stmt.condicao))) {
-                    break;
-                }
-            }
-            try {
-                this.executar(stmt.corpo);
-            }
-            catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ContinueException) {
-                }
-                else {
-                    throw erro;
-                }
-            }
-            if (stmt.incrementar !== null) {
-                this.avaliar(stmt.incrementar);
-            }
-        }
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoFazer = function (stmt) {
-        do {
-            try {
-                this.executar(stmt.doBranch);
-            }
-            catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ContinueException) {
-                }
-                else {
-                    throw erro;
-                }
-            }
-        } while (this.eVerdadeiro(this.avaliar(stmt.whileCondition)));
-    };
-    Interpretador.prototype.visitarExpressaoEscolha = function (stmt) {
-        var switchCondition = this.avaliar(stmt.condicao);
-        var branches = stmt.branches;
-        var defaultBranch = stmt.defaultBranch;
-        var matched = false;
-        try {
-            for (var i = 0; i < branches.length; i++) {
-                var branch = branches[i];
-                for (var j = 0; j < branch.conditions.length; j++) {
-                    if (this.avaliar(branch.conditions[j]) === switchCondition) {
-                        matched = true;
-                        try {
-                            for (var k = 0; k < branch.stmts.length; k++) {
-                                this.executar(branch.stmts[k]);
-                            }
-                        }
-                        catch (erro) {
-                            if (erro instanceof excecoes_1.ContinueException) {
-                            }
-                            else {
-                                throw erro;
-                            }
-                        }
-                    }
-                }
-            }
-            if (defaultBranch !== null && matched === false) {
-                for (var i = 0; i < defaultBranch.stmts.length; i++) {
-                    this.executar(defaultBranch["stmts"][i]);
-                }
-            }
-        }
-        catch (erro) {
-            if (erro instanceof excecoes_1.BreakException) {
-            }
-            else {
-                throw erro;
-            }
-        }
-    };
-    Interpretador.prototype.visitarExpressaoTente = function (stmt) {
-        try {
-            var sucesso = true;
-            try {
-                this.executarBloco(stmt.tryBranch, new ambiente_1.Ambiente(this.ambiente));
-            }
-            catch (erro) {
-                sucesso = false;
-                if (stmt.catchBranch !== null) {
-                    this.executarBloco(stmt.catchBranch, new ambiente_1.Ambiente(this.ambiente));
-                }
-            }
-            if (sucesso && stmt.elseBranch !== null) {
-                this.executarBloco(stmt.elseBranch, new ambiente_1.Ambiente(this.ambiente));
-            }
-        }
-        finally {
-            if (stmt.finallyBranch !== null)
-                this.executarBloco(stmt.finallyBranch, new ambiente_1.Ambiente(this.ambiente));
-        }
-    };
-    Interpretador.prototype.visitarExpressaoEnquanto = function (stmt) {
-        while (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
-            try {
-                this.executar(stmt.corpo);
-            }
-            catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
-                    break;
-                }
-                else if (erro instanceof excecoes_1.ContinueException) {
-                }
-                else {
-                    throw erro;
-                }
-            }
-        }
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoImportar = function (stmt) {
-        var caminhoRelativo = this.avaliar(stmt.caminho);
-        var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-        // const pastaTotal = caminho.dirname(caminhoTotal);
-        var nomeArquivo = caminho.basename(caminhoTotal);
-        var conteudoImportacao;
-        if (!caminhoTotal.endsWith('.egua')) {
-            conteudoImportacao = (0, importar_biblioteca_1.default)(caminhoRelativo);
-            if (conteudoImportacao)
-                return conteudoImportacao;
-        }
-        try {
-            if (!fs.existsSync(caminhoTotal)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, "Não foi possível encontrar arquivo importado.");
-            }
-        }
-        catch (erro) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, "Não foi possível ler o arquivo.");
-        }
-        conteudoImportacao = fs.readFileSync(caminhoTotal).toString();
-        var delegua = new delegua_1.Delegua(this.Delegua.dialeto, nomeArquivo);
-        delegua.executar(conteudoImportacao);
-        // let exportar = delegua.interpretador.global.obterTodasDeleguaFuncao();
-        var exportar = delegua.interpretador.global.valores.exports;
-        var eDicionario = function (objeto) { return objeto.constructor === Object; };
-        if (eDicionario(exportar)) {
-            var novoModulo = new modulo_1.DeleguaModulo();
-            var chaves = Object.keys(exportar);
-            for (var i = 0; i < chaves.length; i++) {
-                novoModulo[chaves[i]] = exportar[chaves[i]];
-            }
-            return novoModulo;
-        }
-        return exportar;
-    };
-    Interpretador.prototype.visitarExpressaoEscreva = function (stmt) {
-        var valor = this.avaliar(stmt.expressao);
-        console.log(this.paraTexto(valor));
-        return null;
-    };
-    Interpretador.prototype.executarBloco = function (declaracoes, ambiente) {
-        var anterior = this.ambiente;
-        try {
-            this.ambiente = ambiente;
-            if (declaracoes && declaracoes.length) {
-                for (var i = 0; i < declaracoes.length; i++) {
-                    this.executar(declaracoes[i]);
-                }
-            }
-        }
-        catch (erro) {
-            // TODO: try sem catch é uma roubada total. Implementar uma forma de quebra de fluxo sem exceção.
-            throw erro;
-        }
-        finally {
-            this.ambiente = anterior;
-        }
-    };
-    Interpretador.prototype.visitarExpressaoBloco = function (stmt) {
-        this.executarBloco(stmt.declaracoes, new ambiente_1.Ambiente(this.ambiente));
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoVar = function (stmt) {
-        var valor = null;
-        if (stmt.inicializador !== null) {
-            valor = this.avaliar(stmt.inicializador);
-        }
-        this.ambiente.definirVariavel(stmt.nome.lexema, valor);
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoContinua = function (stmt) {
-        throw new excecoes_1.ContinueException();
-    };
-    Interpretador.prototype.visitarExpressaoPausa = function (stmt) {
-        throw new excecoes_1.BreakException();
-    };
-    Interpretador.prototype.visitarExpressaoRetornar = function (stmt) {
-        var valor = null;
-        if (stmt.valor != null)
-            valor = this.avaliar(stmt.valor);
-        throw new excecoes_1.ReturnException(valor);
-    };
-    Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expr) {
-        return new funcao_1.DeleguaFuncao(null, expr, this.ambiente, false);
-    };
-    Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        var indice = this.avaliar(expr.indice);
-        var valor = this.avaliar(expr.valor);
-        if (Array.isArray(objeto)) {
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
-                }
-            }
-            while (objeto.length < indice) {
-                objeto.push(null);
-            }
-            objeto[indice] = valor;
-        }
-        else if (objeto.constructor === Object ||
-            objeto instanceof instancia_1.DeleguaInstancia ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof classe_1.DeleguaClasse ||
-            objeto instanceof modulo_1.DeleguaModulo) {
-            objeto[indice] = valor;
-        }
-        else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, "Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.");
-        }
-    };
-    Interpretador.prototype.visitarExpressaoVetorIndice = function (expressao) {
-        var objeto = this.avaliar(expressao.entidadeChamada);
-        var indice = this.avaliar(expressao.indice);
-        if (Array.isArray(objeto)) {
-            if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Somente inteiros podem ser usados para indexar um vetor.");
-            }
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
-                }
-            }
-            if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Índice do vetor fora do intervalo.");
-            }
-            return objeto[indice];
-        }
-        else if (objeto.constructor === Object ||
-            objeto instanceof instancia_1.DeleguaInstancia ||
-            objeto instanceof funcao_1.DeleguaFuncao ||
-            objeto instanceof classe_1.DeleguaClasse ||
-            objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[indice] || null;
-        }
-        else if (typeof objeto === "string") {
-            if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Somente inteiros podem ser usados para indexar um vetor.");
-            }
-            if (indice < 0 && objeto.length !== 0) {
-                while (indice < 0) {
-                    indice += objeto.length;
-                }
-            }
-            if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Índice fora do tamanho.");
-            }
-            return objeto.charAt(indice);
-        }
-        else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, "Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.");
-        }
-    };
-    Interpretador.prototype.visitarExpressaoDefinir = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        if (!(objeto instanceof instancia_1.DeleguaInstancia) &&
-            objeto.constructor !== Object) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, "Somente instâncias e dicionários podem possuir campos.");
-        }
-        var valor = this.avaliar(expr.valor);
-        if (objeto instanceof instancia_1.DeleguaInstancia) {
-            objeto.set(expr.nome, valor);
-            return valor;
-        }
-        else if (objeto.constructor === Object) {
-            objeto[expr.nome.lexema] = valor;
-        }
-    };
-    Interpretador.prototype.visitarExpressaoFuncao = function (stmt) {
-        var funcao = new funcao_1.DeleguaFuncao(stmt.nome.lexema, stmt.funcao, this.ambiente, false);
-        this.ambiente.definirVariavel(stmt.nome.lexema, funcao);
-    };
-    Interpretador.prototype.visitarExpressaoClasse = function (stmt) {
-        var superClasse = null;
-        if (stmt.superClasse !== null) {
-            superClasse = this.avaliar(stmt.superClasse);
-            if (!(superClasse instanceof classe_1.DeleguaClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.superClasse.nome, "SuperClasse precisa ser uma classe.");
-            }
-        }
-        this.ambiente.definirVariavel(stmt.nome.lexema, null);
-        if (stmt.superClasse !== null) {
-            this.ambiente = new ambiente_1.Ambiente(this.ambiente);
-            this.ambiente.definirVariavel("super", superClasse);
-        }
-        var metodos = {};
-        var definirMetodos = stmt.metodos;
-        for (var i = 0; i < stmt.metodos.length; i++) {
-            var metodoAtual = definirMetodos[i];
-            var eInicializado = metodoAtual.nome.lexema === "construtor";
-            var funcao = new funcao_1.DeleguaFuncao(metodoAtual.nome.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
-            metodos[metodoAtual.nome.lexema] = funcao;
-        }
-        var criado = new classe_1.DeleguaClasse(stmt.nome.lexema, superClasse, metodos);
-        if (superClasse !== null) {
-            this.ambiente = this.ambiente.enclosing;
-        }
-        this.ambiente.atribuirVariavel(stmt.nome, criado);
-        return null;
-    };
-    Interpretador.prototype.visitarExpressaoObter = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        if (objeto instanceof instancia_1.DeleguaInstancia) {
-            return objeto.get(expr.nome) || null;
-        }
-        else if (objeto.constructor === Object) {
-            return objeto[expr.nome.lexema] || null;
-        }
-        else if (objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[expr.nome.lexema] || null;
-        }
-        throw new excecoes_1.ErroEmTempoDeExecucao(expr.nome, "Você só pode acessar métodos do objeto e dicionários.");
-    };
-    Interpretador.prototype.visitarExpressaoIsto = function (expr) {
-        return this.procurarVariavel(expr.palavraChave, expr);
-    };
-    Interpretador.prototype.visitarExpressaoDicionario = function (expr) {
-        var dicionario = {};
-        for (var i = 0; i < expr.chaves.length; i++) {
-            dicionario[this.avaliar(expr.chaves[i])] = this.avaliar(expr.valores[i]);
-        }
-        return dicionario;
-    };
-    Interpretador.prototype.visitarExpressaoVetor = function (expr) {
-        var valores = [];
-        for (var i = 0; i < expr.valores.length; i++) {
-            valores.push(this.avaliar(expr.valores[i]));
-        }
-        return valores;
-    };
-    Interpretador.prototype.visitarExpressaoSuper = function (expr) {
-        var distancia = this.locais.get(expr);
-        var superClasse = this.ambiente.obterVariavelEm(distancia, "super");
-        var objeto = this.ambiente.obterVariavelEm(distancia - 1, "isto");
-        var metodo = superClasse.encontrarMetodo(expr.metodo.lexema);
-        if (metodo === undefined) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.metodo, "Método chamado indefinido.");
-        }
-        return metodo.definirEscopo(objeto);
-    };
-    Interpretador.prototype.paraTexto = function (objeto) {
-        if (objeto === null)
-            return "nulo";
-        if (typeof objeto === "boolean") {
-            return objeto ? "verdadeiro" : "falso";
-        }
-        if (objeto instanceof Date) {
-            var formato = Intl.DateTimeFormat("pt", {
-                dateStyle: "full",
-                timeStyle: "full",
-            });
-            return formato.format(objeto);
-        }
-        if (Array.isArray(objeto))
-            return objeto;
-        if (typeof objeto === "object")
-            return JSON.stringify(objeto);
-        return objeto.toString();
-    };
-    Interpretador.prototype.executar = function (stmt, mostrarResultado) {
-        if (mostrarResultado === void 0) { mostrarResultado = false; }
-        var resultado = stmt.aceitar(this);
-        if (mostrarResultado) {
-            console.log(this.paraTexto(resultado));
-        }
-    };
-    Interpretador.prototype.interpretar = function (declaracoes) {
-        try {
-            if (declaracoes.length === 1) {
-                var eObjetoExpressao = declaracoes[0].constructor.name === "Expressao";
-                if (eObjetoExpressao) {
-                    this.executar(declaracoes[0], true);
-                    return;
-                }
-            }
-            for (var i = 0; i < declaracoes.length; i++) {
-                this.executar(declaracoes[i]);
-            }
-        }
-        catch (erro) {
-            this.Delegua.erroEmTempoDeExecucao(erro);
-        }
-    };
-    return Interpretador;
-}());
-exports.Interpretador = Interpretador;
-//# sourceMappingURL=index.js.map