@designliquido/delegua 0.2.6 → 0.2.9

package/fontes/interpretador/interpretador.js

@@ -0,0 +1,691 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interpretador = void 0;
+var caminho = __importStar(require("path"));
+var browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+var tipos_de_simbolos_1 = __importDefault(require("../lexador/tipos-de-simbolos"));
+var ambiente_1 = require("../ambiente");
+var biblioteca_global_1 = __importDefault(require("../bibliotecas/biblioteca-global"));
+var importar_biblioteca_1 = __importDefault(require("../bibliotecas/importar-biblioteca"));
+var excecoes_1 = require("../excecoes");
+var estruturas_1 = require("../estruturas");
+/**
+ * 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(importador, resolvedor, diretorioBase, performance, funcaoDeRetorno) {
+        if (performance === void 0) { performance = false; }
+        this.funcaoDeRetorno = null;
+        this.importador = importador;
+        this.resolvedor = resolvedor;
+        this.diretorioBase = diretorioBase;
+        this.performance = performance;
+        this.funcaoDeRetorno = funcaoDeRetorno || console.log;
+        this.global = new ambiente_1.Ambiente();
+        this.ambiente = this.global;
+        this.locais = new Map();
+        this.erros = [];
+        this.global = (0, biblioteca_global_1.default)(this, this.global);
+    }
+    Interpretador.prototype.resolver = function (expressao, profundidade) {
+        this.locais.set(expressao, profundidade);
+    };
+    Interpretador.prototype.visitarExpressaoLiteral = function (expressao) {
+        return expressao.valor;
+    };
+    Interpretador.prototype.avaliar = function (expressao) {
+        if (expressao.aceitar) {
+            return expressao.aceitar(this);
+        }
+    };
+    Interpretador.prototype.visitarExpressaoAgrupamento = function (expressao) {
+        return this.avaliar(expressao.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.', operador.linha);
+    };
+    Interpretador.prototype.visitarExpressaoUnaria = function (expressao) {
+        var direita = this.avaliar(expressao.direita);
+        switch (expressao.operador.tipo) {
+            case tipos_de_simbolos_1.default.SUBTRACAO:
+                this.verificarOperandoNumero(expressao.operador, direita);
+                return -direita;
+            case tipos_de_simbolos_1.default.NEGACAO:
+                return !this.eVerdadeiro(direita);
+            case tipos_de_simbolos_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.', operador.linha);
+    };
+    Interpretador.prototype.visitarExpressaoBinaria = function (expressao) {
+        var esquerda = this.avaliar(expressao.esquerda);
+        var direita = this.avaliar(expressao.direita);
+        switch (expressao.operador.tipo) {
+            case tipos_de_simbolos_1.default.EXPONENCIACAO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Math.pow(esquerda, direita);
+            case tipos_de_simbolos_1.default.MAIOR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) > Number(direita);
+            case tipos_de_simbolos_1.default.MAIOR_IGUAL:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) >= Number(direita);
+            case tipos_de_simbolos_1.default.MENOR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) < Number(direita);
+            case tipos_de_simbolos_1.default.MENOR_IGUAL:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) <= Number(direita);
+            case tipos_de_simbolos_1.default.SUBTRACAO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) - Number(direita);
+            case tipos_de_simbolos_1.default.ADICAO:
+                if (typeof esquerda === 'number' &&
+                    typeof direita === 'number') {
+                    return Number(esquerda) + Number(direita);
+                }
+                else {
+                    return String(esquerda) + String(direita);
+                }
+            case tipos_de_simbolos_1.default.DIVISAO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) / Number(direita);
+            case tipos_de_simbolos_1.default.MULTIPLICACAO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) * Number(direita);
+            case tipos_de_simbolos_1.default.MODULO:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) % Number(direita);
+            case tipos_de_simbolos_1.default.BIT_AND:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) & Number(direita);
+            case tipos_de_simbolos_1.default.BIT_XOR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) ^ Number(direita);
+            case tipos_de_simbolos_1.default.BIT_OR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) | Number(direita);
+            case tipos_de_simbolos_1.default.MENOR_MENOR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) << Number(direita);
+            case tipos_de_simbolos_1.default.MAIOR_MAIOR:
+                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                return Number(esquerda) >> Number(direita);
+            case tipos_de_simbolos_1.default.DIFERENTE:
+                return !this.eIgual(esquerda, direita);
+            case tipos_de_simbolos_1.default.IGUAL_IGUAL:
+                return this.eIgual(esquerda, direita);
+        }
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoDeChamada = function (expressao) {
+        var entidadeChamada = this.avaliar(expressao.entidadeChamada);
+        var argumentos = [];
+        for (var i = 0; i < expressao.argumentos.length; i++) {
+            argumentos.push(this.avaliar(expressao.argumentos[i]));
+        }
+        if (!(entidadeChamada instanceof estruturas_1.Chamavel)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
+        }
+        var parametros;
+        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
+            parametros = entidadeChamada.declaracao.parametros;
+        }
+        else if (entidadeChamada instanceof estruturas_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 estruturas_1.FuncaoPadrao) {
+            return entidadeChamada.chamar(this, argumentos, expressao.entidadeChamada.nome);
+        }
+        return entidadeChamada.chamar(this, argumentos);
+    };
+    Interpretador.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
+        var valor = this.avaliar(expressao.valor);
+        var distancia = this.locais.get(expressao);
+        if (distancia !== undefined) {
+            this.ambiente.atribuirVariavelEm(distancia, expressao.simbolo, valor);
+        }
+        else {
+            this.ambiente.atribuirVariavel(expressao.simbolo, valor);
+        }
+        return valor;
+    };
+    Interpretador.prototype.procurarVariavel = function (simbolo, expressao) {
+        var distancia = this.locais.get(expressao);
+        if (distancia !== undefined) {
+            return this.ambiente.obterVariavelEm(distancia, simbolo.lexema);
+        }
+        else {
+            return this.global.obterVariavel(simbolo);
+        }
+    };
+    Interpretador.prototype.visitarExpressaoDeVariavel = function (expressao) {
+        return this.procurarVariavel(expressao.simbolo, expressao);
+    };
+    Interpretador.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
+        return this.avaliar(declaracao.expressao);
+    };
+    Interpretador.prototype.visitarExpressaoLogica = function (expressao) {
+        var esquerda = this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === tipos_de_simbolos_1.default.EM) {
+            var direita = this.avaliar(expressao.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(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
+            }
+        }
+        // se um estado for verdadeiro, retorna verdadeiro
+        if (expressao.operador.tipo === tipos_de_simbolos_1.default.OU) {
+            if (this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        // se um estado for falso, retorna falso
+        if (expressao.operador.tipo === tipos_de_simbolos_1.default.E) {
+            if (!this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        return this.avaliar(expressao.direita);
+    };
+    Interpretador.prototype.visitarExpressaoSe = function (declaracao) {
+        if (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+            this.executar(declaracao.caminhoEntao);
+            return null;
+        }
+        for (var i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            var atual = declaracao.caminhosSeSenao[i];
+            if (this.eVerdadeiro(this.avaliar(atual.condicao))) {
+                this.executar(atual.caminho);
+                return null;
+            }
+        }
+        if (declaracao.caminhoSenao !== null) {
+            this.executar(declaracao.caminhoSenao);
+        }
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoPara = function (declaracao) {
+        if (declaracao.inicializador !== null) {
+            this.avaliar(declaracao.inicializador);
+        }
+        while (true) {
+            if (declaracao.condicao !== null) {
+                if (!this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+                    break;
+                }
+            }
+            try {
+                this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
+                    break;
+                }
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
+                }
+                else {
+                    throw erro;
+                }
+            }
+            if (declaracao.incrementar !== null) {
+                this.avaliar(declaracao.incrementar);
+            }
+        }
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoFazer = function (declaracao) {
+        do {
+            try {
+                this.executar(declaracao.caminhoFazer);
+            }
+            catch (erro) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
+                    break;
+                }
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
+                }
+                else {
+                    throw erro;
+                }
+            }
+        } while (this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
+    };
+    Interpretador.prototype.visitarExpressaoEscolha = function (declaracao) {
+        var condicaoEscolha = this.avaliar(declaracao.condicao);
+        var caminhos = declaracao.caminhos;
+        var caminhoPadrao = declaracao.caminhoPadrao;
+        var encontrado = false;
+        try {
+            for (var i = 0; i < caminhos.length; i++) {
+                var caminho_1 = caminhos[i];
+                for (var j = 0; j < caminho_1.conditions.length; j++) {
+                    if (this.avaliar(caminho_1.conditions[j]) === condicaoEscolha) {
+                        encontrado = true;
+                        try {
+                            for (var k = 0; k < caminho_1.declaracoes.length; k++) {
+                                this.executar(caminho_1.declaracoes[k]);
+                            }
+                        }
+                        catch (erro) {
+                            if (erro instanceof excecoes_1.ExcecaoContinuar) {
+                            }
+                            else {
+                                throw erro;
+                            }
+                        }
+                    }
+                }
+            }
+            if (caminhoPadrao !== null && encontrado === false) {
+                for (var i = 0; i < caminhoPadrao.declaracoes.length; i++) {
+                    this.executar(caminhoPadrao['declaracoes'][i]);
+                }
+            }
+        }
+        catch (erro) {
+            if (erro instanceof excecoes_1.ExcecaoSustar) {
+            }
+            else {
+                throw erro;
+            }
+        }
+    };
+    Interpretador.prototype.visitarExpressaoTente = function (declaracao) {
+        try {
+            var sucesso = true;
+            try {
+                this.executarBloco(declaracao.caminhoTente, new ambiente_1.Ambiente(this.ambiente));
+            }
+            catch (erro) {
+                sucesso = false;
+                if (declaracao.caminhoPegue !== null) {
+                    this.executarBloco(declaracao.caminhoPegue, new ambiente_1.Ambiente(this.ambiente));
+                }
+            }
+            if (sucesso && declaracao.caminhoSenao !== null) {
+                this.executarBloco(declaracao.caminhoSenao, new ambiente_1.Ambiente(this.ambiente));
+            }
+        }
+        finally {
+            if (declaracao.caminhoFinalmente !== null)
+                this.executarBloco(declaracao.caminhoFinalmente, new ambiente_1.Ambiente(this.ambiente));
+        }
+    };
+    Interpretador.prototype.visitarExpressaoEnquanto = function (declaracao) {
+        while (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+            try {
+                this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
+                    break;
+                }
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
+                }
+                else {
+                    throw erro;
+                }
+            }
+        }
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoImportar = function (declaracao) {
+        var caminhoRelativo = this.avaliar(declaracao.caminho);
+        var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
+        var nomeArquivo = caminho.basename(caminhoTotal);
+        if (!caminhoTotal.endsWith('.egua') && !caminhoTotal.endsWith('.delegua')) {
+            return (0, importar_biblioteca_1.default)(caminhoRelativo);
+        }
+        var conteudoImportacao = this.importador.importar(caminhoRelativo);
+        var retornoInterpretador = this.interpretar(conteudoImportacao.retornoAvaliadorSintatico);
+        var funcoesDeclaradas = this.global.obterTodasDeleguaFuncao();
+        var eDicionario = function (objeto) { return objeto.constructor === Object; };
+        if (eDicionario(funcoesDeclaradas)) {
+            var novoModulo = new estruturas_1.DeleguaModulo();
+            var chaves = Object.keys(funcoesDeclaradas);
+            for (var i = 0; i < chaves.length; i++) {
+                novoModulo.componentes[chaves[i]] = funcoesDeclaradas[chaves[i]];
+            }
+            return novoModulo;
+        }
+        return funcoesDeclaradas;
+    };
+    Interpretador.prototype.visitarExpressaoEscreva = function (declaracao) {
+        var valor = this.avaliar(declaracao.expressao);
+        this.funcaoDeRetorno(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 (declaracao) {
+        this.executarBloco(declaracao.declaracoes, new ambiente_1.Ambiente(this.ambiente));
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoVar = function (declaracao) {
+        var valor = null;
+        if (declaracao.inicializador !== null) {
+            valor = this.avaliar(declaracao.inicializador);
+        }
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, valor);
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoContinua = function (declaracao) {
+        throw new excecoes_1.ExcecaoContinuar();
+    };
+    Interpretador.prototype.visitarExpressaoSustar = function (declaracao) {
+        throw new excecoes_1.ExcecaoSustar();
+    };
+    Interpretador.prototype.visitarExpressaoRetornar = function (declaracao) {
+        var valor = null;
+        if (declaracao.valor != null)
+            valor = this.avaliar(declaracao.valor);
+        throw new excecoes_1.ExcecaoRetornar(valor);
+    };
+    Interpretador.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
+        return new estruturas_1.DeleguaFuncao(null, expressao, this.ambiente, false);
+    };
+    Interpretador.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        var indice = this.avaliar(expressao.indice);
+        var valor = this.avaliar(expressao.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 estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
+            objeto[indice] = valor;
+        }
+        else {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
+        }
+    };
+    Interpretador.prototype.visitarExpressaoAcessoIndiceVariavel = 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.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
+            }
+            if (indice < 0 && objeto.length !== 0) {
+                while (indice < 0) {
+                    indice += objeto.length;
+                }
+            }
+            if (indice >= objeto.length) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
+            }
+            return objeto[indice];
+        }
+        else if (objeto.constructor === Object ||
+            objeto instanceof estruturas_1.DeleguaInstancia ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto[indice] || null;
+        }
+        else if (typeof objeto === 'string') {
+            if (!Number.isInteger(indice)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
+            }
+            if (indice < 0 && objeto.length !== 0) {
+                while (indice < 0) {
+                    indice += objeto.length;
+                }
+            }
+            if (indice >= objeto.length) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
+            }
+            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.', expressao.linha);
+        }
+    };
+    Interpretador.prototype.visitarExpressaoDefinir = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        if (!(objeto instanceof estruturas_1.DeleguaInstancia) &&
+            objeto.constructor !== Object) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
+        }
+        var valor = this.avaliar(expressao.valor);
+        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+            objeto.set(expressao.nome, valor);
+            return valor;
+        }
+        else if (objeto.constructor === Object) {
+            objeto[expressao.simbolo.lexema] = valor;
+        }
+    };
+    Interpretador.prototype.visitarExpressaoFuncao = function (declaracao) {
+        var funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao, this.ambiente, false);
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, funcao);
+    };
+    Interpretador.prototype.visitarExpressaoClasse = function (declaracao) {
+        var superClasse = null;
+        if (declaracao.superClasse !== null) {
+            superClasse = this.avaliar(declaracao.superClasse);
+            if (!(superClasse instanceof estruturas_1.DeleguaClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
+            }
+        }
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, null);
+        if (declaracao.superClasse !== null) {
+            this.ambiente = new ambiente_1.Ambiente(this.ambiente);
+            this.ambiente.definirVariavel('super', superClasse);
+        }
+        var metodos = {};
+        var definirMetodos = declaracao.metodos;
+        for (var i = 0; i < declaracao.metodos.length; i++) {
+            var metodoAtual = definirMetodos[i];
+            var eInicializado = metodoAtual.simbolo.lexema === 'construtor';
+            var funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
+        }
+        var criado = new estruturas_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
+        if (superClasse !== null) {
+            this.ambiente = this.ambiente.enclosing;
+        }
+        this.ambiente.atribuirVariavel(declaracao.simbolo, criado);
+        return null;
+    };
+    Interpretador.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        if (objeto instanceof estruturas_1.DeleguaInstancia) {
+            return objeto.get(expressao.simbolo) || null;
+        }
+        else if (objeto.constructor === Object) {
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+        else if (objeto instanceof estruturas_1.DeleguaModulo) {
+            return objeto.componentes[expressao.simbolo.lexema] || null;
+        }
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
+    };
+    Interpretador.prototype.visitarExpressaoIsto = function (expressao) {
+        return this.procurarVariavel(expressao.palavraChave, expressao);
+    };
+    Interpretador.prototype.visitarExpressaoDicionario = function (expressao) {
+        var dicionario = {};
+        for (var i = 0; i < expressao.chaves.length; i++) {
+            dicionario[this.avaliar(expressao.chaves[i])] = this.avaliar(expressao.valores[i]);
+        }
+        return dicionario;
+    };
+    Interpretador.prototype.visitarExpressaoVetor = function (expressao) {
+        var valores = [];
+        for (var i = 0; i < expressao.valores.length; i++) {
+            valores.push(this.avaliar(expressao.valores[i]));
+        }
+        return valores;
+    };
+    Interpretador.prototype.visitarExpressaoSuper = function (expressao) {
+        var distancia = this.locais.get(expressao);
+        var superClasse = this.ambiente.obterVariavelEm(distancia, 'super');
+        var objeto = this.ambiente.obterVariavelEm(distancia - 1, 'isto');
+        var metodo = superClasse.encontrarMetodo(expressao.metodo.lexema);
+        if (metodo === undefined) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
+        }
+        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 (declaracao, mostrarResultado) {
+        if (mostrarResultado === void 0) { mostrarResultado = false; }
+        var resultado = declaracao.aceitar(this);
+        if (mostrarResultado) {
+            this.funcaoDeRetorno(this.paraTexto(resultado));
+        }
+    };
+    Interpretador.prototype.interpretar = function (objeto) {
+        this.erros = [];
+        var retornoResolvedor = this.resolvedor.resolver(objeto);
+        this.locais = retornoResolvedor.locais;
+        var inicioInterpretacao = (0, browser_process_hrtime_1.default)();
+        try {
+            var declaracoes = objeto.declaracoes || objeto;
+            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.erros.push(erro);
+        }
+        finally {
+            var deltaInterpretacao = (0, browser_process_hrtime_1.default)(inicioInterpretacao);
+            if (this.performance) {
+                console.log("[Interpretador] Tempo para interpreta\u00E7ao: ".concat(deltaInterpretacao[0] * 1e9 + deltaInterpretacao[1], "ns"));
+            }
+            return {
+                erros: this.erros
+            };
+        }
+    };
+    return Interpretador;
+}());
+exports.Interpretador = Interpretador;
+//# sourceMappingURL=interpretador.js.map